Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

69 files changed, 9868 insertions, 0 deletions

diff --git a/dom/media/mediacontrol/AudioFocusManager.cpp b/dom/media/mediacontrol/AudioFocusManager.cpp
new file mode 100644
index 0000000000..24ac7374d4
--- /dev/null
+++ b/dom/media/mediacontrol/AudioFocusManager.cpp
@@ -0,0 +1,134 @@
+/* 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/. */
+
+#include "AudioFocusManager.h"
+
+#include "MediaController.h"
+#include "MediaControlUtils.h"
+#include "MediaControlService.h"
+#include "mozilla/dom/CanonicalBrowsingContext.h"
+#include "mozilla/Logging.h"
+#include "mozilla/StaticPrefs_media.h"
+#include "mozilla/Telemetry.h"
+#include "nsThreadUtils.h"
+
+#undef LOG
+#define LOG(msg, ...)                        \
+  MOZ_LOG(gMediaControlLog, LogLevel::Debug, \
+          ("AudioFocusManager=%p, " msg, this, ##__VA_ARGS__))
+
+namespace mozilla::dom {
+
+void AudioFocusManager::RequestAudioFocus(IMediaController* aController) {
+  MOZ_ASSERT(aController);
+  if (mOwningFocusControllers.Contains(aController)) {
+    return;
+  }
+  const bool hasManagedAudioFocus = ClearFocusControllersIfNeeded();
+  LOG("Controller %" PRId64 " grants audio focus", aController->Id());
+  mOwningFocusControllers.AppendElement(aController);
+  if (hasManagedAudioFocus) {
+    AccumulateCategorical(
+        mozilla::Telemetry::LABELS_TABS_AUDIO_COMPETITION::ManagedFocusByGecko);
+  } else if (GetAudioFocusNums() == 1) {
+    // Only one audible tab is playing within gecko.
+    AccumulateCategorical(
+        mozilla::Telemetry::LABELS_TABS_AUDIO_COMPETITION::None);
+  } else {
+    // Multiple audible tabs are playing at the same time within gecko.
+    CreateTimerForUpdatingTelemetry();
+  }
+}
+
+void AudioFocusManager::RevokeAudioFocus(IMediaController* aController) {
+  MOZ_ASSERT(aController);
+  if (!mOwningFocusControllers.Contains(aController)) {
+    return;
+  }
+  LOG("Controller %" PRId64 " loses audio focus", aController->Id());
+  mOwningFocusControllers.RemoveElement(aController);
+}
+
+bool AudioFocusManager::ClearFocusControllersIfNeeded() {
+  // Enable audio focus management will start the audio competition which is
+  // only allowing one controller playing at a time.
+  if (!StaticPrefs::media_audioFocus_management()) {
+    return false;
+  }
+
+  bool hasStoppedAnyController = false;
+  for (auto& controller : mOwningFocusControllers) {
+    LOG("Controller %" PRId64 " loses audio focus in audio competitition",
+        controller->Id());
+    hasStoppedAnyController = true;
+    controller->Stop();
+  }
+  mOwningFocusControllers.Clear();
+  return hasStoppedAnyController;
+}
+
+uint32_t AudioFocusManager::GetAudioFocusNums() const {
+  return mOwningFocusControllers.Length();
+}
+
+void AudioFocusManager::CreateTimerForUpdatingTelemetry() {
+  MOZ_ASSERT(NS_IsMainThread());
+  // Already create the timer.
+  if (mTelemetryTimer) {
+    return;
+  }
+
+  const uint32_t focusNum = GetAudioFocusNums();
+  MOZ_ASSERT(focusNum > 1);
+
+  RefPtr<MediaControlService> service = MediaControlService::GetService();
+  MOZ_ASSERT(service);
+  const uint32_t activeControllerNum = service->GetActiveControllersNum();
+
+  // It takes time if users want to manually manage the audio competition by
+  // pausing one of playing tabs. So we will check the status after a short
+  // while to see if users handle the audio competition, or simply ignore it.
+  nsCOMPtr<nsIRunnable> task = NS_NewRunnableFunction(
+      "AudioFocusManager::RequestAudioFocus",
+      [focusNum, activeControllerNum]() {
+        if (RefPtr<MediaControlService> service =
+                MediaControlService::GetService()) {
+          service->GetAudioFocusManager().UpdateTelemetryDataFromTimer(
+              focusNum, activeControllerNum);
+        }
+      });
+  mTelemetryTimer =
+      SimpleTimer::Create(task, 4000, GetMainThreadSerialEventTarget());
+}
+
+void AudioFocusManager::UpdateTelemetryDataFromTimer(
+    uint32_t aPrevFocusNum, uint64_t aPrevActiveControllerNum) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(mTelemetryTimer);
+  // Users pause or mute tabs which decreases the amount of audible playing
+  // tabs, which should not affect the total controller amount.
+  if (GetAudioFocusNums() < aPrevFocusNum) {
+    // If active controller amount is not equal, that means controllers got
+    // deactivated by other reasons, such as reaching to the end, which are not
+    // the situation we would like to accumulate for telemetry.
+    if (MediaControlService::GetService()->GetActiveControllersNum() ==
+        aPrevActiveControllerNum) {
+      AccumulateCategorical(mozilla::Telemetry::LABELS_TABS_AUDIO_COMPETITION::
+                                ManagedFocusByUser);
+    }
+  } else {
+    AccumulateCategorical(
+        mozilla::Telemetry::LABELS_TABS_AUDIO_COMPETITION::Ignored);
+  }
+  mTelemetryTimer = nullptr;
+}
+
+AudioFocusManager::~AudioFocusManager() {
+  if (mTelemetryTimer) {
+    mTelemetryTimer->Cancel();
+    mTelemetryTimer = nullptr;
+  }
+}
+
+}  // namespace mozilla::dom
diff --git a/dom/media/mediacontrol/AudioFocusManager.h b/dom/media/mediacontrol/AudioFocusManager.h
new file mode 100644
index 0000000000..b6047444bb
--- /dev/null
+++ b/dom/media/mediacontrol/AudioFocusManager.h
@@ -0,0 +1,54 @@
+/* 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 DOM_MEDIA_MEDIACONTROL_AUDIOFOCUSMANAGER_H_
+#define DOM_MEDIA_MEDIACONTROL_AUDIOFOCUSMANAGER_H_
+
+#include "base/basictypes.h"
+#include "nsTArray.h"
+#include "VideoUtils.h"
+
+namespace mozilla::dom {
+
+class IMediaController;
+class MediaControlService;
+
+/**
+ * AudioFocusManager is used to assign the audio focus to different requester
+ * and decide which requester can own audio focus when audio competing happens.
+ * When the audio competing happens, the last request would be a winner who can
+ * still own the audio focus, and all the other requesters would lose the audio
+ * focus. Now MediaController is the onlt requester, it would request the audio
+ * focus when it becomes audible and revoke the audio focus when the controller
+ * is no longer active.
+ */
+class AudioFocusManager {
+ public:
+  void RequestAudioFocus(IMediaController* aController);
+  void RevokeAudioFocus(IMediaController* aController);
+
+  explicit AudioFocusManager() = default;
+  ~AudioFocusManager();
+
+  uint32_t GetAudioFocusNums() const;
+
+ private:
+  friend class MediaControlService;
+  // Return true if we manage audio focus by clearing other controllers owning
+  // audio focus before assigning audio focus to the new controller.
+  bool ClearFocusControllersIfNeeded();
+
+  void CreateTimerForUpdatingTelemetry();
+  // This would check if user has managed audio focus by themselves and update
+  // the result to telemetry. This method should only be called from timer.
+  void UpdateTelemetryDataFromTimer(uint32_t aPrevFocusNum,
+                                    uint64_t aPrevActiveControllerNum);
+
+  nsTArray<RefPtr<IMediaController>> mOwningFocusControllers;
+  RefPtr<SimpleTimer> mTelemetryTimer;
+};
+
+}  // namespace mozilla::dom
+
+#endif  //  DOM_MEDIA_MEDIACONTROL_AUDIOFOCUSMANAGER_H_
diff --git a/dom/media/mediacontrol/ContentMediaController.cpp b/dom/media/mediacontrol/ContentMediaController.cpp
new file mode 100644
index 0000000000..a5d19a57c4
--- /dev/null
+++ b/dom/media/mediacontrol/ContentMediaController.cpp
@@ -0,0 +1,376 @@
+/* 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/. */
+
+#include "ContentMediaController.h"
+
+#include "MediaControlUtils.h"
+#include "mozilla/ClearOnShutdown.h"
+#include "mozilla/dom/BrowsingContext.h"
+#include "mozilla/dom/CanonicalBrowsingContext.h"
+#include "mozilla/dom/ContentChild.h"
+#include "mozilla/StaticPtr.h"
+#include "mozilla/Telemetry.h"
+#include "nsGlobalWindowOuter.h"
+
+namespace mozilla::dom {
+
+#undef LOG
+#define LOG(msg, ...)                        \
+  MOZ_LOG(gMediaControlLog, LogLevel::Debug, \
+          ("ContentMediaController=%p, " msg, this, ##__VA_ARGS__))
+
+static Maybe<bool> sXPCOMShutdown;
+
+static void InitXPCOMShutdownMonitor() {
+  if (sXPCOMShutdown) {
+    return;
+  }
+  sXPCOMShutdown.emplace(false);
+  RunOnShutdown([&] { sXPCOMShutdown = Some(true); });
+}
+
+static ContentMediaController* GetContentMediaControllerFromBrowsingContext(
+    BrowsingContext* aBrowsingContext) {
+  MOZ_ASSERT(NS_IsMainThread());
+  InitXPCOMShutdownMonitor();
+  if (!aBrowsingContext || aBrowsingContext->IsDiscarded()) {
+    return nullptr;
+  }
+
+  nsPIDOMWindowOuter* outer = aBrowsingContext->GetDOMWindow();
+  if (!outer) {
+    return nullptr;
+  }
+
+  nsGlobalWindowInner* inner =
+      nsGlobalWindowInner::Cast(outer->GetCurrentInnerWindow());
+  return inner ? inner->GetContentMediaController() : nullptr;
+}
+
+static already_AddRefed<BrowsingContext> GetBrowsingContextForAgent(
+    uint64_t aBrowsingContextId) {
+  // If XPCOM has been shutdown, then we're not able to access browsing context.
+  if (sXPCOMShutdown && *sXPCOMShutdown) {
+    return nullptr;
+  }
+  return BrowsingContext::Get(aBrowsingContextId);
+}
+
+/* static */
+ContentMediaControlKeyReceiver* ContentMediaControlKeyReceiver::Get(
+    BrowsingContext* aBC) {
+  MOZ_ASSERT(NS_IsMainThread());
+  return GetContentMediaControllerFromBrowsingContext(aBC);
+}
+
+/* static */
+ContentMediaAgent* ContentMediaAgent::Get(BrowsingContext* aBC) {
+  MOZ_ASSERT(NS_IsMainThread());
+  return GetContentMediaControllerFromBrowsingContext(aBC);
+}
+
+void ContentMediaAgent::NotifyMediaPlaybackChanged(uint64_t aBrowsingContextId,
+                                                   MediaPlaybackState aState) {
+  MOZ_ASSERT(NS_IsMainThread());
+  RefPtr<BrowsingContext> bc = GetBrowsingContextForAgent(aBrowsingContextId);
+  if (!bc || bc->IsDiscarded()) {
+    return;
+  }
+
+  LOG("Notify media %s in BC %" PRId64, ToMediaPlaybackStateStr(aState),
+      bc->Id());
+  if (XRE_IsContentProcess()) {
+    ContentChild* contentChild = ContentChild::GetSingleton();
+    Unused << contentChild->SendNotifyMediaPlaybackChanged(bc, aState);
+  } else {
+    // Currently this only happen when we disable e10s, otherwise all controlled
+    // media would be run in the content process.
+    if (RefPtr<IMediaInfoUpdater> updater =
+            bc->Canonical()->GetMediaController()) {
+      updater->NotifyMediaPlaybackChanged(bc->Id(), aState);
+    }
+  }
+}
+
+void ContentMediaAgent::NotifyMediaAudibleChanged(uint64_t aBrowsingContextId,
+                                                  MediaAudibleState aState) {
+  MOZ_ASSERT(NS_IsMainThread());
+  RefPtr<BrowsingContext> bc = GetBrowsingContextForAgent(aBrowsingContextId);
+  if (!bc || bc->IsDiscarded()) {
+    return;
+  }
+
+  LOG("Notify media became %s in BC %" PRId64,
+      aState == MediaAudibleState::eAudible ? "audible" : "inaudible",
+      bc->Id());
+  if (XRE_IsContentProcess()) {
+    ContentChild* contentChild = ContentChild::GetSingleton();
+    Unused << contentChild->SendNotifyMediaAudibleChanged(bc, aState);
+  } else {
+    // Currently this only happen when we disable e10s, otherwise all controlled
+    // media would be run in the content process.
+    if (RefPtr<IMediaInfoUpdater> updater =
+            bc->Canonical()->GetMediaController()) {
+      updater->NotifyMediaAudibleChanged(bc->Id(), aState);
+    }
+  }
+}
+
+void ContentMediaAgent::SetIsInPictureInPictureMode(
+    uint64_t aBrowsingContextId, bool aIsInPictureInPictureMode) {
+  MOZ_ASSERT(NS_IsMainThread());
+  RefPtr<BrowsingContext> bc = GetBrowsingContextForAgent(aBrowsingContextId);
+  if (!bc || bc->IsDiscarded()) {
+    return;
+  }
+
+  LOG("Notify media Picture-in-Picture mode '%s' in BC %" PRId64,
+      aIsInPictureInPictureMode ? "enabled" : "disabled", bc->Id());
+  if (XRE_IsContentProcess()) {
+    ContentChild* contentChild = ContentChild::GetSingleton();
+    Unused << contentChild->SendNotifyPictureInPictureModeChanged(
+        bc, aIsInPictureInPictureMode);
+  } else {
+    // Currently this only happen when we disable e10s, otherwise all controlled
+    // media would be run in the content process.
+    if (RefPtr<IMediaInfoUpdater> updater =
+            bc->Canonical()->GetMediaController()) {
+      updater->SetIsInPictureInPictureMode(bc->Id(), aIsInPictureInPictureMode);
+    }
+  }
+}
+
+void ContentMediaAgent::SetDeclaredPlaybackState(
+    uint64_t aBrowsingContextId, MediaSessionPlaybackState aState) {
+  RefPtr<BrowsingContext> bc = GetBrowsingContextForAgent(aBrowsingContextId);
+  if (!bc || bc->IsDiscarded()) {
+    return;
+  }
+
+  LOG("Notify declared playback state  '%s' in BC %" PRId64,
+      ToMediaSessionPlaybackStateStr(aState), bc->Id());
+  if (XRE_IsContentProcess()) {
+    ContentChild* contentChild = ContentChild::GetSingleton();
+    Unused << contentChild->SendNotifyMediaSessionPlaybackStateChanged(bc,
+                                                                       aState);
+    return;
+  }
+  // This would only happen when we disable e10s.
+  if (RefPtr<IMediaInfoUpdater> updater =
+          bc->Canonical()->GetMediaController()) {
+    updater->SetDeclaredPlaybackState(bc->Id(), aState);
+  }
+}
+
+void ContentMediaAgent::NotifySessionCreated(uint64_t aBrowsingContextId) {
+  RefPtr<BrowsingContext> bc = GetBrowsingContextForAgent(aBrowsingContextId);
+  if (!bc || bc->IsDiscarded()) {
+    return;
+  }
+
+  LOG("Notify media session being created in BC %" PRId64, bc->Id());
+  if (XRE_IsContentProcess()) {
+    ContentChild* contentChild = ContentChild::GetSingleton();
+    Unused << contentChild->SendNotifyMediaSessionUpdated(bc, true);
+    return;
+  }
+  // This would only happen when we disable e10s.
+  if (RefPtr<IMediaInfoUpdater> updater =
+          bc->Canonical()->GetMediaController()) {
+    updater->NotifySessionCreated(bc->Id());
+  }
+}
+
+void ContentMediaAgent::NotifySessionDestroyed(uint64_t aBrowsingContextId) {
+  RefPtr<BrowsingContext> bc = GetBrowsingContextForAgent(aBrowsingContextId);
+  if (!bc || bc->IsDiscarded()) {
+    return;
+  }
+
+  LOG("Notify media session being destroyed in BC %" PRId64, bc->Id());
+  if (XRE_IsContentProcess()) {
+    ContentChild* contentChild = ContentChild::GetSingleton();
+    Unused << contentChild->SendNotifyMediaSessionUpdated(bc, false);
+    return;
+  }
+  // This would only happen when we disable e10s.
+  if (RefPtr<IMediaInfoUpdater> updater =
+          bc->Canonical()->GetMediaController()) {
+    updater->NotifySessionDestroyed(bc->Id());
+  }
+}
+
+void ContentMediaAgent::UpdateMetadata(
+    uint64_t aBrowsingContextId, const Maybe<MediaMetadataBase>& aMetadata) {
+  RefPtr<BrowsingContext> bc = GetBrowsingContextForAgent(aBrowsingContextId);
+  if (!bc || bc->IsDiscarded()) {
+    return;
+  }
+
+  LOG("Notify media session metadata change in BC %" PRId64, bc->Id());
+  if (XRE_IsContentProcess()) {
+    ContentChild* contentChild = ContentChild::GetSingleton();
+    Unused << contentChild->SendNotifyUpdateMediaMetadata(bc, aMetadata);
+    return;
+  }
+  // This would only happen when we disable e10s.
+  if (RefPtr<IMediaInfoUpdater> updater =
+          bc->Canonical()->GetMediaController()) {
+    updater->UpdateMetadata(bc->Id(), aMetadata);
+  }
+}
+
+void ContentMediaAgent::EnableAction(uint64_t aBrowsingContextId,
+                                     MediaSessionAction aAction) {
+  RefPtr<BrowsingContext> bc = GetBrowsingContextForAgent(aBrowsingContextId);
+  if (!bc || bc->IsDiscarded()) {
+    return;
+  }
+
+  LOG("Notify to enable action '%s' in BC %" PRId64,
+      ToMediaSessionActionStr(aAction), bc->Id());
+  if (XRE_IsContentProcess()) {
+    ContentChild* contentChild = ContentChild::GetSingleton();
+    Unused << contentChild->SendNotifyMediaSessionSupportedActionChanged(
+        bc, aAction, true);
+    return;
+  }
+  // This would only happen when we disable e10s.
+  if (RefPtr<IMediaInfoUpdater> updater =
+          bc->Canonical()->GetMediaController()) {
+    updater->EnableAction(bc->Id(), aAction);
+  }
+}
+
+void ContentMediaAgent::DisableAction(uint64_t aBrowsingContextId,
+                                      MediaSessionAction aAction) {
+  RefPtr<BrowsingContext> bc = GetBrowsingContextForAgent(aBrowsingContextId);
+  if (!bc || bc->IsDiscarded()) {
+    return;
+  }
+
+  LOG("Notify to disable action '%s' in BC %" PRId64,
+      ToMediaSessionActionStr(aAction), bc->Id());
+  if (XRE_IsContentProcess()) {
+    ContentChild* contentChild = ContentChild::GetSingleton();
+    Unused << contentChild->SendNotifyMediaSessionSupportedActionChanged(
+        bc, aAction, false);
+    return;
+  }
+  // This would only happen when we disable e10s.
+  if (RefPtr<IMediaInfoUpdater> updater =
+          bc->Canonical()->GetMediaController()) {
+    updater->DisableAction(bc->Id(), aAction);
+  }
+}
+
+void ContentMediaAgent::NotifyMediaFullScreenState(uint64_t aBrowsingContextId,
+                                                   bool aIsInFullScreen) {
+  RefPtr<BrowsingContext> bc = GetBrowsingContextForAgent(aBrowsingContextId);
+  if (!bc || bc->IsDiscarded()) {
+    return;
+  }
+
+  LOG("Notify %s fullscreen in BC %" PRId64,
+      aIsInFullScreen ? "entered" : "left", bc->Id());
+  if (XRE_IsContentProcess()) {
+    ContentChild* contentChild = ContentChild::GetSingleton();
+    Unused << contentChild->SendNotifyMediaFullScreenState(bc, aIsInFullScreen);
+    return;
+  }
+  // This would only happen when we disable e10s.
+  if (RefPtr<IMediaInfoUpdater> updater =
+          bc->Canonical()->GetMediaController()) {
+    updater->NotifyMediaFullScreenState(bc->Id(), aIsInFullScreen);
+  }
+}
+
+void ContentMediaAgent::UpdatePositionState(uint64_t aBrowsingContextId,
+                                            const PositionState& aState) {
+  RefPtr<BrowsingContext> bc = GetBrowsingContextForAgent(aBrowsingContextId);
+  if (!bc || bc->IsDiscarded()) {
+    return;
+  }
+  if (XRE_IsContentProcess()) {
+    ContentChild* contentChild = ContentChild::GetSingleton();
+    Unused << contentChild->SendNotifyPositionStateChanged(bc, aState);
+    return;
+  }
+  // This would only happen when we disable e10s.
+  if (RefPtr<IMediaInfoUpdater> updater =
+          bc->Canonical()->GetMediaController()) {
+    updater->UpdatePositionState(bc->Id(), aState);
+  }
+}
+
+ContentMediaController::ContentMediaController(uint64_t aId) {
+  LOG("Create content media controller for BC %" PRId64, aId);
+}
+
+void ContentMediaController::AddReceiver(
+    ContentMediaControlKeyReceiver* aListener) {
+  MOZ_ASSERT(NS_IsMainThread());
+  mReceivers.AppendElement(aListener);
+}
+
+void ContentMediaController::RemoveReceiver(
+    ContentMediaControlKeyReceiver* aListener) {
+  MOZ_ASSERT(NS_IsMainThread());
+  mReceivers.RemoveElement(aListener);
+}
+
+void ContentMediaController::HandleMediaKey(MediaControlKey aKey) {
+  MOZ_ASSERT(NS_IsMainThread());
+  if (mReceivers.IsEmpty()) {
+    return;
+  }
+  LOG("Handle '%s' event, receiver num=%zu", ToMediaControlKeyStr(aKey),
+      mReceivers.Length());
+  // We have default handlers for play, pause and stop.
+  // https://w3c.github.io/mediasession/#ref-for-dom-mediasessionaction-play%E2%91%A3
+  switch (aKey) {
+    case MediaControlKey::Pause:
+      PauseOrStopMedia();
+      return;
+    case MediaControlKey::Play:
+      [[fallthrough]];
+    case MediaControlKey::Stop:
+      // When receiving `Stop`, the amount of receiver would vary during the
+      // iteration, so we use the backward iteration to avoid accessing the
+      // index which is over the array length.
+      for (auto& receiver : Reversed(mReceivers)) {
+        receiver->HandleMediaKey(aKey);
+      }
+      return;
+    default:
+      MOZ_ASSERT_UNREACHABLE("Not supported media key for default handler");
+  }
+}
+
+void ContentMediaController::PauseOrStopMedia() {
+  // When receiving `pause`, if a page contains playing media and paused media
+  // at that moment, that means a user intends to pause those playing
+  // media, not the already paused ones. Then, we're going to stop those already
+  // paused media and keep those latest paused media in `mReceivers`.
+  // The reason for doing that is, when resuming paused media, we only want to
+  // resume latest paused media, not all media, in order to get a better user
+  // experience, which matches Chrome's behavior.
+  bool isAnyMediaPlaying = false;
+  for (const auto& receiver : mReceivers) {
+    if (receiver->IsPlaying()) {
+      isAnyMediaPlaying = true;
+      break;
+    }
+  }
+
+  for (auto& receiver : Reversed(mReceivers)) {
+    if (isAnyMediaPlaying && !receiver->IsPlaying()) {
+      receiver->HandleMediaKey(MediaControlKey::Stop);
+    } else {
+      receiver->HandleMediaKey(MediaControlKey::Pause);
+    }
+  }
+}
+
+}  // namespace mozilla::dom
diff --git a/dom/media/mediacontrol/ContentMediaController.h b/dom/media/mediacontrol/ContentMediaController.h
new file mode 100644
index 0000000000..9e162dbb27
--- /dev/null
+++ b/dom/media/mediacontrol/ContentMediaController.h
@@ -0,0 +1,109 @@
+/* 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 DOM_MEDIA_MEDIACONTROL_CONTENTMEDIACONTROLLER_H_
+#define DOM_MEDIA_MEDIACONTROL_CONTENTMEDIACONTROLLER_H_
+
+#include "MediaControlKeySource.h"
+#include "MediaStatusManager.h"
+
+namespace mozilla::dom {
+
+class BrowsingContext;
+
+/**
+ * ContentMediaControlKeyReceiver is an interface which is used to receive media
+ * control key sent from the chrome process.
+ */
+class ContentMediaControlKeyReceiver {
+ public:
+  NS_INLINE_DECL_PURE_VIRTUAL_REFCOUNTING
+
+  // Return nullptr if the top level browsing context is no longer alive.
+  static ContentMediaControlKeyReceiver* Get(BrowsingContext* aBC);
+
+  // Use this method to handle the event from `ContentMediaAgent`.
+  virtual void HandleMediaKey(MediaControlKey aKey) = 0;
+
+  virtual bool IsPlaying() const = 0;
+};
+
+/**
+ * ContentMediaAgent is an interface which we use to (1) propoagate media
+ * related information from the content process to the chrome process (2) act an
+ * event source to dispatch media control key to its listeners.
+ *
+ * If the media would like to know the media control key, then media MUST
+ * inherit from ContentMediaControlKeyReceiver, and register themselves to
+ * ContentMediaAgent. Whenever media control key delivers, ContentMediaAgent
+ * would notify all its receivers. In addition, whenever controlled media
+ * changes its playback status or audible state, they should update their status
+ * update via ContentMediaAgent.
+ */
+class ContentMediaAgent : public IMediaInfoUpdater {
+ public:
+  // Return nullptr if the top level browsing context is no longer alive.
+  static ContentMediaAgent* Get(BrowsingContext* aBC);
+
+  // IMediaInfoUpdater Methods
+  void NotifyMediaPlaybackChanged(uint64_t aBrowsingContextId,
+                                  MediaPlaybackState aState) override;
+  void NotifyMediaAudibleChanged(uint64_t aBrowsingContextId,
+                                 MediaAudibleState aState) override;
+  void SetIsInPictureInPictureMode(uint64_t aBrowsingContextId,
+                                   bool aIsInPictureInPictureMode) override;
+  void SetDeclaredPlaybackState(uint64_t aBrowsingContextId,
+                                MediaSessionPlaybackState aState) override;
+  void NotifySessionCreated(uint64_t aBrowsingContextId) override;
+  void NotifySessionDestroyed(uint64_t aBrowsingContextId) override;
+  void UpdateMetadata(uint64_t aBrowsingContextId,
+                      const Maybe<MediaMetadataBase>& aMetadata) override;
+  void EnableAction(uint64_t aBrowsingContextId,
+                    MediaSessionAction aAction) override;
+  void DisableAction(uint64_t aBrowsingContextId,
+                     MediaSessionAction aAction) override;
+  void NotifyMediaFullScreenState(uint64_t aBrowsingContextId,
+                                  bool aIsInFullScreen) override;
+  void UpdatePositionState(uint64_t aBrowsingContextId,
+                           const PositionState& aState) override;
+
+  // Use these methods to register/unregister `ContentMediaControlKeyReceiver`
+  // in order to listen to media control key events.
+  virtual void AddReceiver(ContentMediaControlKeyReceiver* aReceiver) = 0;
+  virtual void RemoveReceiver(ContentMediaControlKeyReceiver* aReceiver) = 0;
+};
+
+/**
+ * ContentMediaController exists in per inner window, which has a responsibility
+ * to update the content media state to MediaController (ContentMediaAgent) and
+ * delivers MediaControlKey to its receiver in order to control media in the
+ * content page (ContentMediaControlKeyReceiver).
+ */
+class ContentMediaController final : public ContentMediaAgent,
+                                     public ContentMediaControlKeyReceiver {
+ public:
+  NS_INLINE_DECL_REFCOUNTING(ContentMediaController, override)
+
+  explicit ContentMediaController(uint64_t aId);
+  // ContentMediaAgent methods
+  void AddReceiver(ContentMediaControlKeyReceiver* aListener) override;
+  void RemoveReceiver(ContentMediaControlKeyReceiver* aListener) override;
+
+  // ContentMediaControlKeyReceiver method
+  void HandleMediaKey(MediaControlKey aKey) override;
+
+ private:
+  ~ContentMediaController() = default;
+
+  // We don't need this method, so make it as private and simply return false.
+  virtual bool IsPlaying() const override { return false; }
+
+  void PauseOrStopMedia();
+
+  nsTArray<RefPtr<ContentMediaControlKeyReceiver>> mReceivers;
+};
+
+}  // namespace mozilla::dom
+
+#endif  // DOM_MEDIA_MEDIACONTROL_CONTENTMEDIACONTROLLER_H_
diff --git a/dom/media/mediacontrol/ContentPlaybackController.cpp b/dom/media/mediacontrol/ContentPlaybackController.cpp
new file mode 100644
index 0000000000..ba48c0a5ce
--- /dev/null
+++ b/dom/media/mediacontrol/ContentPlaybackController.cpp
@@ -0,0 +1,210 @@
+/* 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/. */
+
+#include "ContentPlaybackController.h"
+
+#include "MediaControlUtils.h"
+#include "mozilla/dom/ContentMediaController.h"
+#include "mozilla/dom/MediaSession.h"
+#include "mozilla/dom/Navigator.h"
+#include "mozilla/dom/WindowContext.h"
+#include "mozilla/Telemetry.h"
+#include "nsFocusManager.h"
+
+// avoid redefined macro in unified build
+#undef LOG
+#define LOG(msg, ...)                        \
+  MOZ_LOG(gMediaControlLog, LogLevel::Debug, \
+          ("ContentPlaybackController=%p, " msg, this, ##__VA_ARGS__))
+
+namespace mozilla::dom {
+
+ContentPlaybackController::ContentPlaybackController(
+    BrowsingContext* aContext) {
+  MOZ_ASSERT(aContext);
+  mBC = aContext;
+}
+
+MediaSession* ContentPlaybackController::GetMediaSession() const {
+  RefPtr<nsPIDOMWindowOuter> window = mBC->GetDOMWindow();
+  if (!window) {
+    return nullptr;
+  }
+
+  RefPtr<Navigator> navigator = window->GetNavigator();
+  if (!navigator) {
+    return nullptr;
+  }
+
+  return navigator->HasCreatedMediaSession() ? navigator->MediaSession()
+                                             : nullptr;
+}
+
+void ContentPlaybackController::NotifyContentMediaControlKeyReceiver(
+    MediaControlKey aKey) {
+  if (RefPtr<ContentMediaControlKeyReceiver> receiver =
+          ContentMediaControlKeyReceiver::Get(mBC)) {
+    LOG("Handle '%s' in default behavior for BC %" PRIu64,
+        ToMediaControlKeyStr(aKey), mBC->Id());
+    receiver->HandleMediaKey(aKey);
+  }
+}
+
+void ContentPlaybackController::NotifyMediaSession(MediaSessionAction aAction) {
+  MediaSessionActionDetails details;
+  details.mAction = aAction;
+  NotifyMediaSession(details);
+}
+
+void ContentPlaybackController::NotifyMediaSession(
+    const MediaSessionActionDetails& aDetails) {
+  if (RefPtr<MediaSession> session = GetMediaSession()) {
+    LOG("Handle '%s' in media session behavior for BC %" PRIu64,
+        ToMediaSessionActionStr(aDetails.mAction), mBC->Id());
+    MOZ_ASSERT(session->IsActive(), "Notify inactive media session!");
+    session->NotifyHandler(aDetails);
+  }
+}
+
+void ContentPlaybackController::NotifyMediaSessionWhenActionIsSupported(
+    MediaSessionAction aAction) {
+  if (IsMediaSessionActionSupported(aAction)) {
+    NotifyMediaSession(aAction);
+  }
+}
+
+bool ContentPlaybackController::IsMediaSessionActionSupported(
+    MediaSessionAction aAction) const {
+  RefPtr<MediaSession> session = GetMediaSession();
+  return session ? session->IsActive() && session->IsSupportedAction(aAction)
+                 : false;
+}
+
+Maybe<uint64_t> ContentPlaybackController::GetActiveMediaSessionId() const {
+  RefPtr<WindowContext> wc = mBC->GetTopWindowContext();
+  return wc ? wc->GetActiveMediaSessionContextId() : Nothing();
+}
+
+void ContentPlaybackController::Focus() {
+  // Focus is not part of the MediaSession standard, so always use the
+  // default behavior and focus the window currently playing media.
+  if (nsCOMPtr<nsPIDOMWindowOuter> win = mBC->GetDOMWindow()) {
+    nsFocusManager::FocusWindow(win, CallerType::System);
+  }
+}
+
+void ContentPlaybackController::Play() {
+  const MediaSessionAction action = MediaSessionAction::Play;
+  RefPtr<MediaSession> session = GetMediaSession();
+  if (IsMediaSessionActionSupported(action)) {
+    NotifyMediaSession(action);
+  }
+  // We don't want to arbitrarily call play default handler, because we want to
+  // resume the frame which a user really gets interest in, not all media in the
+  // same page. Therefore, we would only call default handler for `play` when
+  // (1) We don't have an active media session (If we have one, the play action
+  // handler should only be triggered on that session)
+  // (2) Active media session without setting action handler for `play`
+  else if (!GetActiveMediaSessionId() || (session && session->IsActive())) {
+    NotifyContentMediaControlKeyReceiver(MediaControlKey::Play);
+  }
+}
+
+void ContentPlaybackController::Pause() {
+  const MediaSessionAction action = MediaSessionAction::Pause;
+  if (IsMediaSessionActionSupported(action)) {
+    NotifyMediaSession(action);
+  } else {
+    NotifyContentMediaControlKeyReceiver(MediaControlKey::Pause);
+  }
+}
+
+void ContentPlaybackController::SeekBackward() {
+  NotifyMediaSessionWhenActionIsSupported(MediaSessionAction::Seekbackward);
+}
+
+void ContentPlaybackController::SeekForward() {
+  NotifyMediaSessionWhenActionIsSupported(MediaSessionAction::Seekforward);
+}
+
+void ContentPlaybackController::PreviousTrack() {
+  NotifyMediaSessionWhenActionIsSupported(MediaSessionAction::Previoustrack);
+}
+
+void ContentPlaybackController::NextTrack() {
+  NotifyMediaSessionWhenActionIsSupported(MediaSessionAction::Nexttrack);
+}
+
+void ContentPlaybackController::SkipAd() {
+  NotifyMediaSessionWhenActionIsSupported(MediaSessionAction::Skipad);
+}
+
+void ContentPlaybackController::Stop() {
+  const MediaSessionAction action = MediaSessionAction::Stop;
+  if (IsMediaSessionActionSupported(action)) {
+    NotifyMediaSession(action);
+  } else {
+    NotifyContentMediaControlKeyReceiver(MediaControlKey::Stop);
+  }
+}
+
+void ContentPlaybackController::SeekTo(double aSeekTime, bool aFastSeek) {
+  MediaSessionActionDetails details;
+  details.mAction = MediaSessionAction::Seekto;
+  details.mSeekTime.Construct(aSeekTime);
+  if (aFastSeek) {
+    details.mFastSeek.Construct(aFastSeek);
+  }
+  if (IsMediaSessionActionSupported(details.mAction)) {
+    NotifyMediaSession(details);
+  }
+}
+
+void ContentMediaControlKeyHandler::HandleMediaControlAction(
+    BrowsingContext* aContext, const MediaControlAction& aAction) {
+  MOZ_ASSERT(aContext);
+  // The web content doesn't exist in this browsing context.
+  if (!aContext->GetDocShell()) {
+    return;
+  }
+  ContentPlaybackController controller(aContext);
+  switch (aAction.mKey) {
+    case MediaControlKey::Focus:
+      controller.Focus();
+      return;
+    case MediaControlKey::Play:
+      controller.Play();
+      return;
+    case MediaControlKey::Pause:
+      controller.Pause();
+      return;
+    case MediaControlKey::Stop:
+      controller.Stop();
+      return;
+    case MediaControlKey::Previoustrack:
+      controller.PreviousTrack();
+      return;
+    case MediaControlKey::Nexttrack:
+      controller.NextTrack();
+      return;
+    case MediaControlKey::Seekbackward:
+      controller.SeekBackward();
+      return;
+    case MediaControlKey::Seekforward:
+      controller.SeekForward();
+      return;
+    case MediaControlKey::Skipad:
+      controller.SkipAd();
+      return;
+    case MediaControlKey::Seekto: {
+      const SeekDetails& details = *aAction.mDetails;
+      controller.SeekTo(details.mSeekTime, details.mFastSeek);
+      return;
+    }
+    default:
+      MOZ_ASSERT_UNREACHABLE("Invalid media control key.");
+  };
+}
+
+}  // namespace mozilla::dom
diff --git a/dom/media/mediacontrol/ContentPlaybackController.h b/dom/media/mediacontrol/ContentPlaybackController.h
new file mode 100644
index 0000000000..a692dedde0
--- /dev/null
+++ b/dom/media/mediacontrol/ContentPlaybackController.h
@@ -0,0 +1,73 @@
+/* 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 DOM_MEDIA_MEDIACONTROL_CONTENTPLAYBACKCONTROLLER_H_
+#define DOM_MEDIA_MEDIACONTROL_CONTENTPLAYBACKCONTROLLER_H_
+
+#include "MediaControlKeySource.h"
+#include "nsPIDOMWindow.h"
+#include "mozilla/dom/BrowsingContext.h"
+
+namespace mozilla::dom {
+
+class MediaSession;
+
+/**
+ * This interface is used to handle different playback control actions in the
+ * content process. Most of the methods are designed based on the
+ * MediaSessionAction values, which are defined in the media session spec [1].
+ *
+ * The reason we need that is to explicitly separate the implementation from all
+ * different defined methods. If we want to add a new method in the future, we
+ * can do that without modifying other methods.
+ *
+ * If the active media session has a corresponding MediaSessionActionHandler,
+ * then we would invoke it, or we would do nothing. However, for certain
+ * actions, such as `play`, `pause` and `stop`, we have default action handling
+ * in order to control playback correctly even if the website doesn't use media
+ * session at all or the media session doesn't have correspending action handler
+ * [2].
+ *
+ * [1] https://w3c.github.io/mediasession/#enumdef-mediasessionaction
+ * [2]
+ * https://w3c.github.io/mediasession/#ref-for-active-media-session%E2%91%A1%E2%93%AA
+ */
+class MOZ_STACK_CLASS ContentPlaybackController {
+ public:
+  explicit ContentPlaybackController(BrowsingContext* aContext);
+  ~ContentPlaybackController() = default;
+
+  // TODO: Convert Focus() to MOZ_CAN_RUN_SCRIPT
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY void Focus();
+  void Play();
+  void Pause();
+  void SeekBackward();
+  void SeekForward();
+  void PreviousTrack();
+  void NextTrack();
+  void SkipAd();
+  void Stop();
+  void SeekTo(double aSeekTime, bool aFastSeek);
+
+ private:
+  void NotifyContentMediaControlKeyReceiver(MediaControlKey aKey);
+  void NotifyMediaSession(MediaSessionAction aAction);
+  void NotifyMediaSession(const MediaSessionActionDetails& aDetails);
+  void NotifyMediaSessionWhenActionIsSupported(MediaSessionAction aAction);
+  bool IsMediaSessionActionSupported(MediaSessionAction aAction) const;
+  Maybe<uint64_t> GetActiveMediaSessionId() const;
+  MediaSession* GetMediaSession() const;
+
+  RefPtr<BrowsingContext> mBC;
+};
+
+class ContentMediaControlKeyHandler {
+ public:
+  static void HandleMediaControlAction(BrowsingContext* aContext,
+                                       const MediaControlAction& aAction);
+};
+
+}  // namespace mozilla::dom
+
+#endif
diff --git a/dom/media/mediacontrol/FetchImageHelper.cpp b/dom/media/mediacontrol/FetchImageHelper.cpp
new file mode 100644
index 0000000000..8ba8d54485
--- /dev/null
+++ b/dom/media/mediacontrol/FetchImageHelper.cpp
@@ -0,0 +1,164 @@
+/* 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/. */
+
+#include "FetchImageHelper.h"
+
+#include "mozilla/gfx/2D.h"
+#include "mozilla/Logging.h"
+#include "mozilla/NullPrincipal.h"
+#include "nsIChannel.h"
+#include "nsNetUtil.h"
+
+mozilla::LazyLogModule gFetchImageLog("FetchImageHelper");
+
+#undef LOG
+#define LOG(msg, ...)                      \
+  MOZ_LOG(gFetchImageLog, LogLevel::Debug, \
+          ("FetchImageHelper=%p, " msg, this, ##__VA_ARGS__))
+
+using namespace mozilla::gfx;
+
+namespace mozilla::dom {
+
+FetchImageHelper::FetchImageHelper(const MediaImage& aImage)
+    : mSrc(aImage.mSrc) {}
+
+FetchImageHelper::~FetchImageHelper() { AbortFetchingImage(); }
+
+RefPtr<ImagePromise> FetchImageHelper::FetchImage() {
+  MOZ_ASSERT(NS_IsMainThread());
+  if (IsFetchingImage()) {
+    return mPromise.Ensure(__func__);
+  }
+
+  LOG("Start fetching image from %s", NS_ConvertUTF16toUTF8(mSrc).get());
+  nsCOMPtr<nsIURI> uri;
+  if (NS_FAILED(NS_NewURI(getter_AddRefs(uri), mSrc))) {
+    LOG("Failed to create URI");
+    return ImagePromise::CreateAndReject(false, __func__);
+  }
+
+  MOZ_ASSERT(!mListener);
+  mListener = new ImageFetchListener();
+  if (NS_FAILED(mListener->FetchDecodedImageFromURI(uri, this))) {
+    LOG("Failed to decode image from async channel");
+    return ImagePromise::CreateAndReject(false, __func__);
+  }
+  return mPromise.Ensure(__func__);
+}
+
+void FetchImageHelper::AbortFetchingImage() {
+  MOZ_ASSERT(NS_IsMainThread());
+  LOG("AbortFetchingImage");
+  mPromise.RejectIfExists(false, __func__);
+  ClearListenerIfNeeded();
+}
+
+void FetchImageHelper::ClearListenerIfNeeded() {
+  if (mListener) {
+    mListener->Clear();
+    mListener = nullptr;
+  }
+}
+
+bool FetchImageHelper::IsFetchingImage() const {
+  MOZ_ASSERT(NS_IsMainThread());
+  return !mPromise.IsEmpty() && mListener;
+}
+
+void FetchImageHelper::HandleFetchSuccess(imgIContainer* aImage) {
+  MOZ_ASSERT(aImage);
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(IsFetchingImage());
+  LOG("Finished fetching image");
+  mPromise.Resolve(aImage, __func__);
+  ClearListenerIfNeeded();
+}
+
+void FetchImageHelper::HandleFetchFail() {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(IsFetchingImage());
+  LOG("Reject the promise because of fetching failed");
+  mPromise.RejectIfExists(false, __func__);
+  ClearListenerIfNeeded();
+}
+
+/**
+ * Implementation for FetchImageHelper::ImageFetchListener
+ */
+NS_IMPL_ISUPPORTS(FetchImageHelper::ImageFetchListener, imgIContainerCallback)
+
+FetchImageHelper::ImageFetchListener::~ImageFetchListener() {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(!mHelper, "Cancel() should be called before desturction!");
+}
+
+nsresult FetchImageHelper::ImageFetchListener::FetchDecodedImageFromURI(
+    nsIURI* aURI, FetchImageHelper* aHelper) {
+  MOZ_ASSERT(!mHelper && !mChannel,
+             "Should call Clear() berfore running another fetching process!");
+  RefPtr<nsIPrincipal> nullPrincipal =
+      NullPrincipal::CreateWithoutOriginAttributes();
+  nsCOMPtr<nsIChannel> channel;
+  nsresult rv =
+      NS_NewChannel(getter_AddRefs(channel), aURI, nullPrincipal,
+                    nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_SEC_CONTEXT_IS_NULL,
+                    nsIContentPolicy::TYPE_INTERNAL_IMAGE, nullptr, nullptr,
+                    nullptr, nullptr, nsIRequest::LOAD_ANONYMOUS);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  nsCOMPtr<imgITools> imgTools = do_GetService("@mozilla.org/image/tools;1");
+  if (!imgTools) {
+    return NS_ERROR_FAILURE;
+  }
+
+  rv = imgTools->DecodeImageFromChannelAsync(aURI, channel, this, nullptr);
+  if (NS_FAILED(rv)) {
+    return NS_ERROR_FAILURE;
+  }
+  MOZ_ASSERT(aHelper);
+  mHelper = aHelper;
+  mChannel = channel;
+  return NS_OK;
+}
+
+void FetchImageHelper::ImageFetchListener::Clear() {
+  MOZ_ASSERT(NS_IsMainThread());
+  if (mChannel) {
+    mChannel->CancelWithReason(
+        NS_BINDING_ABORTED, "FetchImageHelper::ImageFetchListener::Clear"_ns);
+    mChannel = nullptr;
+  }
+  mHelper = nullptr;
+}
+
+bool FetchImageHelper::ImageFetchListener::IsFetchingImage() const {
+  MOZ_ASSERT(NS_IsMainThread());
+  return mHelper ? mHelper->IsFetchingImage() : false;
+}
+
+NS_IMETHODIMP FetchImageHelper::ImageFetchListener::OnImageReady(
+    imgIContainer* aImage, nsresult aStatus) {
+  MOZ_ASSERT(NS_IsMainThread());
+  if (!IsFetchingImage()) {
+    return NS_OK;
+  }
+  // We have received image, so we don't need the channel anymore.
+  mChannel = nullptr;
+
+  MOZ_ASSERT(mHelper);
+  if (NS_FAILED(aStatus) || !aImage) {
+    mHelper->HandleFetchFail();
+    Clear();
+    return aStatus;
+  }
+
+  mHelper->HandleFetchSuccess(aImage);
+
+  return NS_OK;
+}
+
+}  // namespace mozilla::dom
diff --git a/dom/media/mediacontrol/FetchImageHelper.h b/dom/media/mediacontrol/FetchImageHelper.h
new file mode 100644
index 0000000000..eb3e719610
--- /dev/null
+++ b/dom/media/mediacontrol/FetchImageHelper.h
@@ -0,0 +1,82 @@
+/* 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 DOM_MEDIA_MEDIACONTROL_FETCHIMAGEHELPER_H_
+#define DOM_MEDIA_MEDIACONTROL_FETCHIMAGEHELPER_H_
+
+#include "imgIContainer.h"
+#include "imgITools.h"
+#include "mozilla/dom/MediaSessionBinding.h"
+#include "mozilla/MozPromise.h"
+
+namespace mozilla::dom {
+/**
+ * FetchImageHelper is used to fetch image data from MediaImage, and the fetched
+ * image data would be used to show on the virtual control inferface. The URL of
+ * MediaImage is defined by websites by using MediaSession API [1].
+ *
+ * By using `FetchImage()`, it would return a promise that would resolve with a
+ * `imgIContainer`, then we can get the image data from the container.
+ *
+ * [1] https://w3c.github.io/mediasession/#dictdef-mediaimage
+ */
+using ImagePromise = MozPromise<nsCOMPtr<imgIContainer>, bool,
+                                /* IsExclusive = */ true>;
+class FetchImageHelper final {
+ public:
+  explicit FetchImageHelper(const MediaImage& aImage);
+  ~FetchImageHelper();
+
+  // Return a promise which would be resolved with the decoded image surface
+  // when we finish fetching and decoding image data, and it would be rejected
+  // when we fail to fecth the image.
+  RefPtr<ImagePromise> FetchImage();
+
+  // Stop fetching and decoding image and reject the image promise. If we have
+  // not started yet fetching image, then nothing would happen.
+  void AbortFetchingImage();
+
+  // Return true if we're fecthing image.
+  bool IsFetchingImage() const;
+
+ private:
+  /**
+   * ImageFetchListener is used to listen the notification of finishing fetching
+   * image data (via `OnImageReady()`) and finishing decoding image data (via
+   * `Notify()`).
+   */
+  class ImageFetchListener final : public imgIContainerCallback {
+   public:
+    NS_DECL_ISUPPORTS
+    ImageFetchListener() = default;
+
+    // Start an async channel to load the image, and return error if the channel
+    // opens failed. It would use `aHelper::HandleFetchSuccess/Fail()` to notify
+    // the result asynchronously.
+    nsresult FetchDecodedImageFromURI(nsIURI* aURI, FetchImageHelper* aHelper);
+    void Clear();
+    bool IsFetchingImage() const;
+
+    // Method of imgIContainerCallback
+    NS_IMETHOD OnImageReady(imgIContainer* aImage, nsresult aStatus) override;
+
+   private:
+    ~ImageFetchListener();
+
+    FetchImageHelper* MOZ_NON_OWNING_REF mHelper = nullptr;
+    nsCOMPtr<nsIChannel> mChannel;
+  };
+
+  void ClearListenerIfNeeded();
+  void HandleFetchSuccess(imgIContainer* aImage);
+  void HandleFetchFail();
+
+  nsString mSrc;
+  MozPromiseHolder<ImagePromise> mPromise;
+  RefPtr<ImageFetchListener> mListener;
+};
+
+}  // namespace mozilla::dom
+
+#endif  // DOM_MEDIA_MEDIACONTROL_FETCHIMAGEHELPER_H_
diff --git a/dom/media/mediacontrol/MediaControlIPC.h b/dom/media/mediacontrol/MediaControlIPC.h
new file mode 100644
index 0000000000..100e5832c2
--- /dev/null
+++ b/dom/media/mediacontrol/MediaControlIPC.h
@@ -0,0 +1,75 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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 ipc_MediaControlIPC_h
+#define ipc_MediaControlIPC_h
+
+#include "ipc/EnumSerializer.h"
+
+#include "mozilla/dom/MediaControllerBinding.h"
+#include "mozilla/dom/MediaControlKeySource.h"
+#include "mozilla/dom/MediaPlaybackStatus.h"
+
+namespace IPC {
+template <>
+struct ParamTraits<mozilla::dom::MediaControlKey>
+    : public ContiguousEnumSerializerInclusive<
+          mozilla::dom::MediaControlKey, mozilla::dom::MediaControlKey::Focus,
+          mozilla::dom::MediaControlKey::Stop> {};
+
+template <>
+struct ParamTraits<mozilla::dom::MediaPlaybackState>
+    : public ContiguousEnumSerializerInclusive<
+          mozilla::dom::MediaPlaybackState,
+          mozilla::dom::MediaPlaybackState::eStarted,
+          mozilla::dom::MediaPlaybackState::eStopped> {};
+
+template <>
+struct ParamTraits<mozilla::dom::MediaAudibleState>
+    : public ContiguousEnumSerializerInclusive<
+          mozilla::dom::MediaAudibleState,
+          mozilla::dom::MediaAudibleState::eInaudible,
+          mozilla::dom::MediaAudibleState::eAudible> {};
+
+template <>
+struct ParamTraits<mozilla::dom::SeekDetails> {
+  typedef mozilla::dom::SeekDetails paramType;
+
+  static void Write(MessageWriter* aWriter, const paramType& aParam) {
+    WriteParam(aWriter, aParam.mSeekTime);
+    WriteParam(aWriter, aParam.mFastSeek);
+  }
+
+  static bool Read(MessageReader* aReader, paramType* aResult) {
+    if (!ReadParam(aReader, &aResult->mSeekTime) ||
+        !ReadParam(aReader, &aResult->mFastSeek)) {
+      return false;
+    }
+    return true;
+  }
+};
+
+template <>
+struct ParamTraits<mozilla::dom::MediaControlAction> {
+  typedef mozilla::dom::MediaControlAction paramType;
+
+  static void Write(MessageWriter* aWriter, const paramType& aParam) {
+    WriteParam(aWriter, aParam.mKey);
+    WriteParam(aWriter, aParam.mDetails);
+  }
+
+  static bool Read(MessageReader* aReader, paramType* aResult) {
+    if (!ReadParam(aReader, &aResult->mKey) ||
+        !ReadParam(aReader, &aResult->mDetails)) {
+      return false;
+    }
+    return true;
+  }
+};
+
+}  // namespace IPC
+
+#endif  // mozilla_MediaControlIPC_hh
diff --git a/dom/media/mediacontrol/MediaControlKeyManager.cpp b/dom/media/mediacontrol/MediaControlKeyManager.cpp
new file mode 100644
index 0000000000..4cb562aa84
--- /dev/null
+++ b/dom/media/mediacontrol/MediaControlKeyManager.cpp
@@ -0,0 +1,228 @@
+/* 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/. */
+
+#include "MediaControlKeyManager.h"
+
+#include "MediaControlUtils.h"
+#include "MediaControlService.h"
+#include "mozilla/AbstractThread.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/Logging.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/Services.h"
+#include "mozilla/StaticPrefs_media.h"
+#include "mozilla/widget/MediaKeysEventSourceFactory.h"
+#include "nsContentUtils.h"
+#include "nsIObserverService.h"
+
+#undef LOG
+#define LOG(msg, ...)                        \
+  MOZ_LOG(gMediaControlLog, LogLevel::Debug, \
+          ("MediaControlKeyManager=%p, " msg, this, ##__VA_ARGS__))
+
+#undef LOG_INFO
+#define LOG_INFO(msg, ...)                  \
+  MOZ_LOG(gMediaControlLog, LogLevel::Info, \
+          ("MediaControlKeyManager=%p, " msg, this, ##__VA_ARGS__))
+
+#define MEDIA_CONTROL_PREF "media.hardwaremediakeys.enabled"
+
+namespace mozilla::dom {
+
+bool MediaControlKeyManager::IsOpened() const {
+  return mEventSource && mEventSource->IsOpened();
+}
+
+bool MediaControlKeyManager::Open() {
+  if (IsOpened()) {
+    return true;
+  }
+  const bool isEnabledMediaControl = StartMonitoringControlKeys();
+  if (isEnabledMediaControl) {
+    RefPtr<MediaControlService> service = MediaControlService::GetService();
+    MOZ_ASSERT(service);
+    service->NotifyMediaControlHasEverBeenEnabled();
+  }
+  return isEnabledMediaControl;
+}
+
+void MediaControlKeyManager::Close() {
+  // We don't call parent's `Close()` because we want to keep the listener
+  // (MediaControlKeyHandler) all the time. It would be manually removed by
+  // `MediaControlService` when shutdown.
+  StopMonitoringControlKeys();
+}
+
+MediaControlKeyManager::MediaControlKeyManager()
+    : mObserver(new Observer(this)) {
+  nsContentUtils::RegisterShutdownObserver(mObserver);
+  Preferences::AddStrongObserver(mObserver, MEDIA_CONTROL_PREF);
+}
+
+MediaControlKeyManager::~MediaControlKeyManager() { Shutdown(); }
+
+void MediaControlKeyManager::Shutdown() {
+  StopMonitoringControlKeys();
+  mEventSource = nullptr;
+  if (mObserver) {
+    nsContentUtils::UnregisterShutdownObserver(mObserver);
+    Preferences::RemoveObserver(mObserver, MEDIA_CONTROL_PREF);
+    mObserver = nullptr;
+  }
+}
+
+bool MediaControlKeyManager::StartMonitoringControlKeys() {
+  if (!StaticPrefs::media_hardwaremediakeys_enabled()) {
+    return false;
+  }
+
+  if (!mEventSource) {
+    mEventSource = widget::CreateMediaControlKeySource();
+  }
+  if (mEventSource && mEventSource->Open()) {
+    LOG_INFO("StartMonitoringControlKeys");
+    mEventSource->SetPlaybackState(mPlaybackState);
+    mEventSource->SetMediaMetadata(mMetadata);
+    mEventSource->SetSupportedMediaKeys(mSupportedKeys);
+    mEventSource->AddListener(this);
+    return true;
+  }
+  // Fail to open or create event source (eg. when cross-compiling with MinGW,
+  // we cannot use the related WinAPI)
+  return false;
+}
+
+void MediaControlKeyManager::StopMonitoringControlKeys() {
+  if (!mEventSource || !mEventSource->IsOpened()) {
+    return;
+  }
+
+  LOG_INFO("StopMonitoringControlKeys");
+  mEventSource->Close();
+  if (StaticPrefs::media_mediacontrol_testingevents_enabled()) {
+    // Close the source would reset the displayed playback state and metadata.
+    if (nsCOMPtr<nsIObserverService> obs = services::GetObserverService()) {
+      obs->NotifyObservers(nullptr, "media-displayed-playback-changed",
+                           nullptr);
+      obs->NotifyObservers(nullptr, "media-displayed-metadata-changed",
+                           nullptr);
+    }
+  }
+}
+
+void MediaControlKeyManager::OnActionPerformed(
+    const MediaControlAction& aAction) {
+  for (auto listener : mListeners) {
+    listener->OnActionPerformed(aAction);
+  }
+}
+
+void MediaControlKeyManager::SetPlaybackState(
+    MediaSessionPlaybackState aState) {
+  if (mEventSource && mEventSource->IsOpened()) {
+    mEventSource->SetPlaybackState(aState);
+  }
+  mPlaybackState = aState;
+  LOG_INFO("playbackState=%s", ToMediaSessionPlaybackStateStr(mPlaybackState));
+  if (StaticPrefs::media_mediacontrol_testingevents_enabled()) {
+    if (nsCOMPtr<nsIObserverService> obs = services::GetObserverService()) {
+      obs->NotifyObservers(nullptr, "media-displayed-playback-changed",
+                           nullptr);
+    }
+  }
+}
+
+MediaSessionPlaybackState MediaControlKeyManager::GetPlaybackState() const {
+  return (mEventSource && mEventSource->IsOpened())
+             ? mEventSource->GetPlaybackState()
+             : mPlaybackState;
+}
+
+void MediaControlKeyManager::SetMediaMetadata(
+    const MediaMetadataBase& aMetadata) {
+  if (mEventSource && mEventSource->IsOpened()) {
+    mEventSource->SetMediaMetadata(aMetadata);
+  }
+  mMetadata = aMetadata;
+  LOG_INFO("title=%s, artist=%s album=%s",
+           NS_ConvertUTF16toUTF8(mMetadata.mTitle).get(),
+           NS_ConvertUTF16toUTF8(mMetadata.mArtist).get(),
+           NS_ConvertUTF16toUTF8(mMetadata.mAlbum).get());
+  if (StaticPrefs::media_mediacontrol_testingevents_enabled()) {
+    if (nsCOMPtr<nsIObserverService> obs = services::GetObserverService()) {
+      obs->NotifyObservers(nullptr, "media-displayed-metadata-changed",
+                           nullptr);
+    }
+  }
+}
+
+void MediaControlKeyManager::SetSupportedMediaKeys(
+    const MediaKeysArray& aSupportedKeys) {
+  mSupportedKeys.Clear();
+  for (const auto& key : aSupportedKeys) {
+    LOG_INFO("Supported keys=%s", ToMediaControlKeyStr(key));
+    mSupportedKeys.AppendElement(key);
+  }
+  if (mEventSource && mEventSource->IsOpened()) {
+    mEventSource->SetSupportedMediaKeys(mSupportedKeys);
+  }
+}
+
+void MediaControlKeyManager::SetEnableFullScreen(bool aIsEnabled) {
+  LOG_INFO("Set fullscreen %s", aIsEnabled ? "enabled" : "disabled");
+  if (mEventSource && mEventSource->IsOpened()) {
+    mEventSource->SetEnableFullScreen(aIsEnabled);
+  }
+}
+
+void MediaControlKeyManager::SetEnablePictureInPictureMode(bool aIsEnabled) {
+  LOG_INFO("Set Picture-In-Picture mode %s",
+           aIsEnabled ? "enabled" : "disabled");
+  if (mEventSource && mEventSource->IsOpened()) {
+    mEventSource->SetEnablePictureInPictureMode(aIsEnabled);
+  }
+}
+
+void MediaControlKeyManager::SetPositionState(const PositionState& aState) {
+  LOG_INFO("Set PositionState, duration=%f, playbackRate=%f, position=%f",
+           aState.mDuration, aState.mPlaybackRate,
+           aState.mLastReportedPlaybackPosition);
+  if (mEventSource && mEventSource->IsOpened()) {
+    mEventSource->SetPositionState(aState);
+  }
+}
+
+void MediaControlKeyManager::OnPreferenceChange() {
+  const bool isPrefEnabled = StaticPrefs::media_hardwaremediakeys_enabled();
+  // Only start monitoring control keys when the pref is on and having a main
+  // controller that means already having media which need to be controlled.
+  const bool shouldMonitorKeys =
+      isPrefEnabled && MediaControlService::GetService()->GetMainController();
+  LOG_INFO("Preference change : %s media control",
+           isPrefEnabled ? "enable" : "disable");
+  if (shouldMonitorKeys) {
+    Unused << StartMonitoringControlKeys();
+  } else {
+    StopMonitoringControlKeys();
+  }
+}
+
+NS_IMPL_ISUPPORTS(MediaControlKeyManager::Observer, nsIObserver);
+
+MediaControlKeyManager::Observer::Observer(MediaControlKeyManager* aManager)
+    : mManager(aManager) {}
+
+NS_IMETHODIMP
+MediaControlKeyManager::Observer::Observe(nsISupports* aSubject,
+                                          const char* aTopic,
+                                          const char16_t* aData) {
+  if (!strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID)) {
+    mManager->Shutdown();
+  } else if (!strcmp(aTopic, "nsPref:changed")) {
+    mManager->OnPreferenceChange();
+  }
+  return NS_OK;
+}
+
+}  // namespace mozilla::dom
diff --git a/dom/media/mediacontrol/MediaControlKeyManager.h b/dom/media/mediacontrol/MediaControlKeyManager.h
new file mode 100644
index 0000000000..feb857e335
--- /dev/null
+++ b/dom/media/mediacontrol/MediaControlKeyManager.h
@@ -0,0 +1,73 @@
+/* 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 DOM_MEDIA_MEDIACONTROL_MEDIACONTROLKEYMANAGER_H_
+#define DOM_MEDIA_MEDIACONTROL_MEDIACONTROLKEYMANAGER_H_
+
+#include "MediaControlKeySource.h"
+#include "MediaEventSource.h"
+#include "nsIObserver.h"
+
+namespace mozilla::dom {
+
+/**
+ * MediaControlKeyManager is a wrapper of MediaControlKeySource, which
+ * is used to manage creating and destroying a real media keys event source.
+ *
+ * It monitors the amount of the media controller in MediaService, and would
+ * create the event source when there is any existing controller and destroy it
+ * when there is no controller.
+ */
+class MediaControlKeyManager final : public MediaControlKeySource,
+                                     public MediaControlKeyListener {
+ public:
+  NS_INLINE_DECL_REFCOUNTING(MediaControlKeyManager, override)
+
+  MediaControlKeyManager();
+
+  // MediaControlKeySource methods
+  bool Open() override;
+  void Close() override;
+  bool IsOpened() const override;
+
+  void SetPlaybackState(MediaSessionPlaybackState aState) override;
+  MediaSessionPlaybackState GetPlaybackState() const override;
+
+  // MediaControlKeyListener methods
+  void OnActionPerformed(const MediaControlAction& aAction) override;
+
+  void SetMediaMetadata(const MediaMetadataBase& aMetadata) override;
+  void SetSupportedMediaKeys(const MediaKeysArray& aSupportedKeys) override;
+  void SetEnableFullScreen(bool aIsEnabled) override;
+  void SetEnablePictureInPictureMode(bool aIsEnabled) override;
+  void SetPositionState(const PositionState& aState) override;
+
+ private:
+  ~MediaControlKeyManager();
+  void Shutdown();
+
+  class Observer final : public nsIObserver {
+   public:
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSIOBSERVER
+    explicit Observer(MediaControlKeyManager* aManager);
+
+   protected:
+    virtual ~Observer() = default;
+
+    MediaControlKeyManager* MOZ_OWNING_REF mManager;
+  };
+  RefPtr<Observer> mObserver;
+  void OnPreferenceChange();
+
+  bool StartMonitoringControlKeys();
+  void StopMonitoringControlKeys();
+  RefPtr<MediaControlKeySource> mEventSource;
+  MediaMetadataBase mMetadata;
+  nsTArray<MediaControlKey> mSupportedKeys;
+};
+
+}  // namespace mozilla::dom
+
+#endif
diff --git a/dom/media/mediacontrol/MediaControlKeySource.cpp b/dom/media/mediacontrol/MediaControlKeySource.cpp
new file mode 100644
index 0000000000..22756c860a
--- /dev/null
+++ b/dom/media/mediacontrol/MediaControlKeySource.cpp
@@ -0,0 +1,122 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#include "MediaControlKeySource.h"
+
+#include "MediaController.h"
+#include "MediaControlUtils.h"
+#include "MediaControlService.h"
+#include "mozilla/Logging.h"
+
+namespace mozilla::dom {
+
+// avoid redefined macro in unified build
+#undef LOG_SOURCE
+#define LOG_SOURCE(msg, ...)                 \
+  MOZ_LOG(gMediaControlLog, LogLevel::Debug, \
+          ("MediaControlKeySource=%p, " msg, this, ##__VA_ARGS__))
+
+#undef LOG_KEY
+#define LOG_KEY(msg, key, ...)                                                 \
+  MOZ_LOG(gMediaControlLog, LogLevel::Debug,                                   \
+          ("MediaControlKeyHandler=%p, " msg, this, ToMediaControlKeyStr(key), \
+           ##__VA_ARGS__));
+
+void MediaControlKeyHandler::OnActionPerformed(
+    const MediaControlAction& aAction) {
+  LOG_KEY("OnActionPerformed '%s'", aAction.mKey);
+
+  RefPtr<MediaControlService> service = MediaControlService::GetService();
+  MOZ_ASSERT(service);
+  RefPtr<IMediaController> controller = service->GetMainController();
+  if (!controller) {
+    return;
+  }
+
+  switch (aAction.mKey) {
+    case MediaControlKey::Focus:
+      controller->Focus();
+      return;
+    case MediaControlKey::Play:
+      controller->Play();
+      return;
+    case MediaControlKey::Pause:
+      controller->Pause();
+      return;
+    case MediaControlKey::Playpause: {
+      if (controller->IsPlaying()) {
+        controller->Pause();
+      } else {
+        controller->Play();
+      }
+      return;
+    }
+    case MediaControlKey::Previoustrack:
+      controller->PrevTrack();
+      return;
+    case MediaControlKey::Nexttrack:
+      controller->NextTrack();
+      return;
+    case MediaControlKey::Seekbackward:
+      controller->SeekBackward();
+      return;
+    case MediaControlKey::Seekforward:
+      controller->SeekForward();
+      return;
+    case MediaControlKey::Skipad:
+      controller->SkipAd();
+      return;
+    case MediaControlKey::Seekto: {
+      const SeekDetails& details = *aAction.mDetails;
+      controller->SeekTo(details.mSeekTime, details.mFastSeek);
+      return;
+    }
+    case MediaControlKey::Stop:
+      controller->Stop();
+      return;
+    default:
+      MOZ_ASSERT_UNREACHABLE("Error : undefined media key!");
+      return;
+  }
+}
+
+MediaControlKeySource::MediaControlKeySource()
+    : mPlaybackState(MediaSessionPlaybackState::None) {}
+
+void MediaControlKeySource::AddListener(MediaControlKeyListener* aListener) {
+  MOZ_ASSERT(aListener);
+  LOG_SOURCE("Add listener %p", aListener);
+  mListeners.AppendElement(aListener);
+}
+
+void MediaControlKeySource::RemoveListener(MediaControlKeyListener* aListener) {
+  MOZ_ASSERT(aListener);
+  LOG_SOURCE("Remove listener %p", aListener);
+  mListeners.RemoveElement(aListener);
+}
+
+size_t MediaControlKeySource::GetListenersNum() const {
+  return mListeners.Length();
+}
+
+void MediaControlKeySource::Close() {
+  LOG_SOURCE("Close source");
+  mListeners.Clear();
+}
+
+void MediaControlKeySource::SetPlaybackState(MediaSessionPlaybackState aState) {
+  if (mPlaybackState == aState) {
+    return;
+  }
+  LOG_SOURCE("SetPlaybackState '%s'", ToMediaSessionPlaybackStateStr(aState));
+  mPlaybackState = aState;
+}
+
+MediaSessionPlaybackState MediaControlKeySource::GetPlaybackState() const {
+  return mPlaybackState;
+}
+
+}  // namespace mozilla::dom
diff --git a/dom/media/mediacontrol/MediaControlKeySource.h b/dom/media/mediacontrol/MediaControlKeySource.h
new file mode 100644
index 0000000000..f5d62a429e
--- /dev/null
+++ b/dom/media/mediacontrol/MediaControlKeySource.h
@@ -0,0 +1,122 @@
+/* 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 DOM_MEDIA_MEDIACONTROL_MEDIACONTROLKEYSOURCE_H_
+#define DOM_MEDIA_MEDIACONTROL_MEDIACONTROLKEYSOURCE_H_
+
+#include "mozilla/dom/MediaControllerBinding.h"
+#include "mozilla/dom/MediaMetadata.h"
+#include "mozilla/dom/MediaSession.h"
+#include "mozilla/dom/MediaSessionBinding.h"
+#include "nsISupportsImpl.h"
+#include "nsTArray.h"
+
+namespace mozilla::dom {
+
+// This is used to store seek related properties from MediaSessionActionDetails.
+// However, currently we have no plan to support `seekOffset`.
+// https://w3c.github.io/mediasession/#the-mediasessionactiondetails-dictionary
+struct SeekDetails {
+  SeekDetails() = default;
+  explicit SeekDetails(double aSeekTime) : mSeekTime(aSeekTime) {}
+  SeekDetails(double aSeekTime, bool aFastSeek)
+      : mSeekTime(aSeekTime), mFastSeek(aFastSeek) {}
+  double mSeekTime = 0.0;
+  bool mFastSeek = false;
+};
+
+struct MediaControlAction {
+  MediaControlAction() = default;
+  explicit MediaControlAction(MediaControlKey aKey) : mKey(aKey) {}
+  MediaControlAction(MediaControlKey aKey, const SeekDetails& aDetails)
+      : mKey(aKey), mDetails(Some(aDetails)) {}
+  MediaControlKey mKey = MediaControlKey::EndGuard_;
+  Maybe<SeekDetails> mDetails;
+};
+
+/**
+ * MediaControlKeyListener is a pure interface, which is used to monitor
+ * MediaControlKey, we can add it onto the MediaControlKeySource,
+ * and then everytime when the media key events occur, `OnActionPerformed` will
+ * be called so that we can do related handling.
+ */
+class MediaControlKeyListener {
+ public:
+  NS_INLINE_DECL_PURE_VIRTUAL_REFCOUNTING
+  MediaControlKeyListener() = default;
+
+  virtual void OnActionPerformed(const MediaControlAction& aAction) = 0;
+
+ protected:
+  virtual ~MediaControlKeyListener() = default;
+};
+
+/**
+ * MediaControlKeyHandler is used to operate media controller by corresponding
+ * received media control key events.
+ */
+class MediaControlKeyHandler final : public MediaControlKeyListener {
+ public:
+  NS_INLINE_DECL_REFCOUNTING(MediaControlKeyHandler, override)
+  void OnActionPerformed(const MediaControlAction& aAction) override;
+
+ private:
+  virtual ~MediaControlKeyHandler() = default;
+};
+
+/**
+ * MediaControlKeySource is an abstract class which is used to implement
+ * transporting media control keys event to all its listeners when media keys
+ * event happens.
+ */
+class MediaControlKeySource {
+ public:
+  NS_INLINE_DECL_PURE_VIRTUAL_REFCOUNTING
+  MediaControlKeySource();
+
+  using MediaKeysArray = nsTArray<MediaControlKey>;
+
+  virtual void AddListener(MediaControlKeyListener* aListener);
+  virtual void RemoveListener(MediaControlKeyListener* aListener);
+  size_t GetListenersNum() const;
+
+  // Return true if the initialization of the source succeeds, and inherited
+  // sources should implement this method to handle the initialization fails.
+  virtual bool Open() = 0;
+  virtual void Close();
+  virtual bool IsOpened() const = 0;
+
+  /**
+   * All following `SetXXX()` functions are used to update the playback related
+   * properties change from a specific tab, which can represent the playback
+   * status for Firefox instance. Even if we have multiple tabs playing media at
+   * the same time, we would only update information from one of that tabs that
+   * would be done by `MediaControlService`.
+   */
+  virtual void SetPlaybackState(MediaSessionPlaybackState aState);
+  virtual MediaSessionPlaybackState GetPlaybackState() const;
+
+  // Override this method if the event source needs to handle the metadata.
+  virtual void SetMediaMetadata(const MediaMetadataBase& aMetadata) {}
+
+  // Set the supported media keys which the event source can use to determine
+  // what kinds of buttons should be shown on the UI.
+  virtual void SetSupportedMediaKeys(const MediaKeysArray& aSupportedKeys) = 0;
+
+  // Override these methods if the inherited key source want to know the change
+  // for following attributes. For example, GeckoView would use these methods
+  // to notify change to the embedded application.
+  virtual void SetEnableFullScreen(bool aIsEnabled){};
+  virtual void SetEnablePictureInPictureMode(bool aIsEnabled){};
+  virtual void SetPositionState(const PositionState& aState){};
+
+ protected:
+  virtual ~MediaControlKeySource() = default;
+  nsTArray<RefPtr<MediaControlKeyListener>> mListeners;
+  MediaSessionPlaybackState mPlaybackState;
+};
+
+}  // namespace mozilla::dom
+
+#endif
diff --git a/dom/media/mediacontrol/MediaControlService.cpp b/dom/media/mediacontrol/MediaControlService.cpp
new file mode 100644
index 0000000000..c321e080d2
--- /dev/null
+++ b/dom/media/mediacontrol/MediaControlService.cpp
@@ -0,0 +1,540 @@
+/* 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/. */
+
+#include "MediaControlService.h"
+
+#include "MediaController.h"
+#include "MediaControlUtils.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/intl/Localization.h"
+#include "mozilla/Logging.h"
+#include "mozilla/Services.h"
+#include "mozilla/StaticPrefs_media.h"
+#include "mozilla/StaticPtr.h"
+#include "mozilla/Telemetry.h"
+#include "nsIObserverService.h"
+#include "nsXULAppAPI.h"
+
+using mozilla::intl::Localization;
+
+#undef LOG
+#define LOG(msg, ...)                        \
+  MOZ_LOG(gMediaControlLog, LogLevel::Debug, \
+          ("MediaControlService=%p, " msg, this, ##__VA_ARGS__))
+
+#undef LOG_MAINCONTROLLER
+#define LOG_MAINCONTROLLER(msg, ...) \
+  MOZ_LOG(gMediaControlLog, LogLevel::Debug, (msg, ##__VA_ARGS__))
+
+#undef LOG_MAINCONTROLLER_INFO
+#define LOG_MAINCONTROLLER_INFO(msg, ...) \
+  MOZ_LOG(gMediaControlLog, LogLevel::Info, (msg, ##__VA_ARGS__))
+
+namespace mozilla::dom {
+
+StaticRefPtr<MediaControlService> gMediaControlService;
+static bool sIsXPCOMShutdown = false;
+
+/* static */
+RefPtr<MediaControlService> MediaControlService::GetService() {
+  MOZ_DIAGNOSTIC_ASSERT(XRE_IsParentProcess(),
+                        "MediaControlService only runs on Chrome process!");
+  if (sIsXPCOMShutdown) {
+    return nullptr;
+  }
+  if (!gMediaControlService) {
+    gMediaControlService = new MediaControlService();
+    gMediaControlService->Init();
+  }
+  RefPtr<MediaControlService> service = gMediaControlService.get();
+  return service;
+}
+
+/* static */
+void MediaControlService::GenerateMediaControlKey(const GlobalObject& global,
+                                                  MediaControlKey aKey) {
+  RefPtr<MediaControlService> service = MediaControlService::GetService();
+  if (service) {
+    service->GenerateTestMediaControlKey(aKey);
+  }
+}
+
+/* static */
+void MediaControlService::GetCurrentActiveMediaMetadata(
+    const GlobalObject& aGlobal, MediaMetadataInit& aMetadata) {
+  if (RefPtr<MediaControlService> service = MediaControlService::GetService()) {
+    MediaMetadataBase metadata = service->GetMainControllerMediaMetadata();
+    aMetadata.mTitle = metadata.mTitle;
+    aMetadata.mArtist = metadata.mArtist;
+    aMetadata.mAlbum = metadata.mAlbum;
+    for (const auto& artwork : metadata.mArtwork) {
+      // If OOM happens resulting in not able to append the element, then we
+      // would get incorrect result and fail on test, so we don't need to throw
+      // an error explicitly.
+      if (MediaImage* image = aMetadata.mArtwork.AppendElement(fallible)) {
+        image->mSrc = artwork.mSrc;
+        image->mSizes = artwork.mSizes;
+        image->mType = artwork.mType;
+      }
+    }
+  }
+}
+
+/* static */
+MediaSessionPlaybackState
+MediaControlService::GetCurrentMediaSessionPlaybackState(
+    GlobalObject& aGlobal) {
+  if (RefPtr<MediaControlService> service = MediaControlService::GetService()) {
+    return service->GetMainControllerPlaybackState();
+  }
+  return MediaSessionPlaybackState::None;
+}
+
+NS_INTERFACE_MAP_BEGIN(MediaControlService)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIObserver)
+  NS_INTERFACE_MAP_ENTRY(nsIObserver)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_ADDREF(MediaControlService)
+NS_IMPL_RELEASE(MediaControlService)
+
+MediaControlService::MediaControlService() {
+  LOG("create media control service");
+  RefPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+  if (obs) {
+    obs->AddObserver(this, "xpcom-shutdown", false);
+  }
+}
+
+void MediaControlService::Init() {
+  mMediaKeysHandler = new MediaControlKeyHandler();
+  mMediaControlKeyManager = new MediaControlKeyManager();
+  mMediaControlKeyManager->AddListener(mMediaKeysHandler.get());
+  mControllerManager = MakeUnique<ControllerManager>(this);
+
+  // Initialize the fallback title
+  nsTArray<nsCString> resIds{
+      "branding/brand.ftl"_ns,
+      "dom/media.ftl"_ns,
+  };
+  RefPtr<Localization> l10n = Localization::Create(resIds, true);
+  {
+    nsAutoCString translation;
+    IgnoredErrorResult rv;
+    l10n->FormatValueSync("mediastatus-fallback-title"_ns, {}, translation, rv);
+    if (!rv.Failed()) {
+      mFallbackTitle = NS_ConvertUTF8toUTF16(translation);
+    }
+  }
+}
+
+MediaControlService::~MediaControlService() {
+  LOG("destroy media control service");
+  Shutdown();
+}
+
+void MediaControlService::NotifyMediaControlHasEverBeenUsed() {
+  // We've already updated the telemetry for using meida control.
+  if (mHasEverUsedMediaControl) {
+    return;
+  }
+  mHasEverUsedMediaControl = true;
+  const uint32_t usedOnMediaControl = 1;
+#ifdef XP_WIN
+  Telemetry::ScalarSet(Telemetry::ScalarID::MEDIA_CONTROL_PLATFORM_USAGE,
+                       u"Windows"_ns, usedOnMediaControl);
+#endif
+#ifdef XP_MACOSX
+  Telemetry::ScalarSet(Telemetry::ScalarID::MEDIA_CONTROL_PLATFORM_USAGE,
+                       u"MacOS"_ns, usedOnMediaControl);
+#endif
+#ifdef MOZ_WIDGET_GTK
+  Telemetry::ScalarSet(Telemetry::ScalarID::MEDIA_CONTROL_PLATFORM_USAGE,
+                       u"Linux"_ns, usedOnMediaControl);
+#endif
+#ifdef MOZ_WIDGET_ANDROID
+  Telemetry::ScalarSet(Telemetry::ScalarID::MEDIA_CONTROL_PLATFORM_USAGE,
+                       u"Android"_ns, usedOnMediaControl);
+#endif
+}
+
+void MediaControlService::NotifyMediaControlHasEverBeenEnabled() {
+  // We've already enabled the service and update the telemetry.
+  if (mHasEverEnabledMediaControl) {
+    return;
+  }
+  mHasEverEnabledMediaControl = true;
+  const uint32_t enableOnMediaControl = 0;
+#ifdef XP_WIN
+  Telemetry::ScalarSet(Telemetry::ScalarID::MEDIA_CONTROL_PLATFORM_USAGE,
+                       u"Windows"_ns, enableOnMediaControl);
+#endif
+#ifdef XP_MACOSX
+  Telemetry::ScalarSet(Telemetry::ScalarID::MEDIA_CONTROL_PLATFORM_USAGE,
+                       u"MacOS"_ns, enableOnMediaControl);
+#endif
+#ifdef MOZ_WIDGET_GTK
+  Telemetry::ScalarSet(Telemetry::ScalarID::MEDIA_CONTROL_PLATFORM_USAGE,
+                       u"Linux"_ns, enableOnMediaControl);
+#endif
+#ifdef MOZ_WIDGET_ANDROID
+  Telemetry::ScalarSet(Telemetry::ScalarID::MEDIA_CONTROL_PLATFORM_USAGE,
+                       u"Android"_ns, enableOnMediaControl);
+#endif
+}
+
+NS_IMETHODIMP
+MediaControlService::Observe(nsISupports* aSubject, const char* aTopic,
+                             const char16_t* aData) {
+  if (!strcmp(aTopic, "xpcom-shutdown")) {
+    LOG("XPCOM shutdown");
+    MOZ_ASSERT(gMediaControlService);
+    RefPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+    if (obs) {
+      obs->RemoveObserver(this, "xpcom-shutdown");
+    }
+    Shutdown();
+    sIsXPCOMShutdown = true;
+    gMediaControlService = nullptr;
+  }
+  return NS_OK;
+}
+
+void MediaControlService::Shutdown() {
+  mControllerManager->Shutdown();
+  mMediaControlKeyManager->RemoveListener(mMediaKeysHandler.get());
+}
+
+bool MediaControlService::RegisterActiveMediaController(
+    MediaController* aController) {
+  MOZ_DIAGNOSTIC_ASSERT(mControllerManager,
+                        "Register controller before initializing service");
+  if (!mControllerManager->AddController(aController)) {
+    LOG("Fail to register controller %" PRId64, aController->Id());
+    return false;
+  }
+  LOG("Register media controller %" PRId64 ", currentNum=%" PRId64,
+      aController->Id(), GetActiveControllersNum());
+  if (StaticPrefs::media_mediacontrol_testingevents_enabled()) {
+    if (nsCOMPtr<nsIObserverService> obs = services::GetObserverService()) {
+      obs->NotifyObservers(nullptr, "media-controller-amount-changed", nullptr);
+    }
+  }
+  return true;
+}
+
+bool MediaControlService::UnregisterActiveMediaController(
+    MediaController* aController) {
+  MOZ_DIAGNOSTIC_ASSERT(mControllerManager,
+                        "Unregister controller before initializing service");
+  if (!mControllerManager->RemoveController(aController)) {
+    LOG("Fail to unregister controller %" PRId64, aController->Id());
+    return false;
+  }
+  LOG("Unregister media controller %" PRId64 ", currentNum=%" PRId64,
+      aController->Id(), GetActiveControllersNum());
+  if (StaticPrefs::media_mediacontrol_testingevents_enabled()) {
+    if (nsCOMPtr<nsIObserverService> obs = services::GetObserverService()) {
+      obs->NotifyObservers(nullptr, "media-controller-amount-changed", nullptr);
+    }
+  }
+  return true;
+}
+
+void MediaControlService::NotifyControllerPlaybackStateChanged(
+    MediaController* aController) {
+  MOZ_DIAGNOSTIC_ASSERT(
+      mControllerManager,
+      "controller state change happens before initializing service");
+  MOZ_DIAGNOSTIC_ASSERT(aController);
+  // The controller is not an active controller.
+  if (!mControllerManager->Contains(aController)) {
+    return;
+  }
+
+  // The controller is the main controller, propagate its playback state.
+  if (GetMainController() == aController) {
+    mControllerManager->MainControllerPlaybackStateChanged(
+        aController->PlaybackState());
+    return;
+  }
+
+  // The controller is not the main controller, but will become a new main
+  // controller. As the service can contains multiple controllers and only one
+  // controller can be controlled by media control keys. Therefore, when
+  // controller's state becomes `playing`, then we would like to let that
+  // controller being controlled, rather than other controller which might not
+  // be playing at the time.
+  if (GetMainController() != aController &&
+      aController->PlaybackState() == MediaSessionPlaybackState::Playing) {
+    mControllerManager->UpdateMainControllerIfNeeded(aController);
+  }
+}
+
+void MediaControlService::RequestUpdateMainController(
+    MediaController* aController) {
+  MOZ_DIAGNOSTIC_ASSERT(aController);
+  MOZ_DIAGNOSTIC_ASSERT(
+      mControllerManager,
+      "using controller in PIP mode before initializing service");
+  // The controller is not an active controller.
+  if (!mControllerManager->Contains(aController)) {
+    return;
+  }
+  mControllerManager->UpdateMainControllerIfNeeded(aController);
+}
+
+uint64_t MediaControlService::GetActiveControllersNum() const {
+  MOZ_DIAGNOSTIC_ASSERT(mControllerManager);
+  return mControllerManager->GetControllersNum();
+}
+
+MediaController* MediaControlService::GetMainController() const {
+  MOZ_DIAGNOSTIC_ASSERT(mControllerManager);
+  return mControllerManager->GetMainController();
+}
+
+void MediaControlService::GenerateTestMediaControlKey(MediaControlKey aKey) {
+  if (!StaticPrefs::media_mediacontrol_testingevents_enabled()) {
+    return;
+  }
+  // Generate a seek details for `seekto`
+  if (aKey == MediaControlKey::Seekto) {
+    mMediaKeysHandler->OnActionPerformed(
+        MediaControlAction(aKey, SeekDetails()));
+  } else {
+    mMediaKeysHandler->OnActionPerformed(MediaControlAction(aKey));
+  }
+}
+
+MediaMetadataBase MediaControlService::GetMainControllerMediaMetadata() const {
+  MediaMetadataBase metadata;
+  if (!StaticPrefs::media_mediacontrol_testingevents_enabled()) {
+    return metadata;
+  }
+  return GetMainController() ? GetMainController()->GetCurrentMediaMetadata()
+                             : metadata;
+}
+
+MediaSessionPlaybackState MediaControlService::GetMainControllerPlaybackState()
+    const {
+  if (!StaticPrefs::media_mediacontrol_testingevents_enabled()) {
+    return MediaSessionPlaybackState::None;
+  }
+  return GetMainController() ? GetMainController()->PlaybackState()
+                             : MediaSessionPlaybackState::None;
+}
+
+nsString MediaControlService::GetFallbackTitle() const {
+  return mFallbackTitle;
+}
+
+// Following functions belong to ControllerManager
+MediaControlService::ControllerManager::ControllerManager(
+    MediaControlService* aService)
+    : mSource(aService->GetMediaControlKeySource()) {
+  MOZ_ASSERT(mSource);
+}
+
+bool MediaControlService::ControllerManager::AddController(
+    MediaController* aController) {
+  MOZ_DIAGNOSTIC_ASSERT(aController);
+  if (mControllers.contains(aController)) {
+    return false;
+  }
+  mControllers.insertBack(aController);
+  UpdateMainControllerIfNeeded(aController);
+  return true;
+}
+
+bool MediaControlService::ControllerManager::RemoveController(
+    MediaController* aController) {
+  MOZ_DIAGNOSTIC_ASSERT(aController);
+  if (!mControllers.contains(aController)) {
+    return false;
+  }
+  // This is LinkedListElement's method which will remove controller from
+  // `mController`.
+  static_cast<LinkedListControllerPtr>(aController)->remove();
+  // If main controller is removed from the list, the last controller in the
+  // list would become the main controller. Or reset the main controller when
+  // the list is already empty.
+  if (GetMainController() == aController) {
+    UpdateMainControllerInternal(
+        mControllers.isEmpty() ? nullptr : mControllers.getLast());
+  }
+  return true;
+}
+
+void MediaControlService::ControllerManager::UpdateMainControllerIfNeeded(
+    MediaController* aController) {
+  MOZ_DIAGNOSTIC_ASSERT(aController);
+
+  if (GetMainController() == aController) {
+    LOG_MAINCONTROLLER("This controller is alreay the main controller");
+    return;
+  }
+
+  if (GetMainController() &&
+      GetMainController()->IsBeingUsedInPIPModeOrFullscreen() &&
+      !aController->IsBeingUsedInPIPModeOrFullscreen()) {
+    LOG_MAINCONTROLLER(
+        "Normal media controller can't replace the controller being used in "
+        "PIP mode or fullscreen");
+    return ReorderGivenController(aController,
+                                  InsertOptions::eInsertAsNormalController);
+  }
+  ReorderGivenController(aController, InsertOptions::eInsertAsMainController);
+  UpdateMainControllerInternal(aController);
+}
+
+void MediaControlService::ControllerManager::ReorderGivenController(
+    MediaController* aController, InsertOptions aOption) {
+  MOZ_DIAGNOSTIC_ASSERT(aController);
+  MOZ_DIAGNOSTIC_ASSERT(mControllers.contains(aController));
+  // Reset the controller's position and make it not in any list.
+  static_cast<LinkedListControllerPtr>(aController)->remove();
+
+  if (aOption == InsertOptions::eInsertAsMainController) {
+    // Make the main controller as the last element in the list to maintain the
+    // order of controllers because we always use the last controller in the
+    // list as the next main controller when removing current main controller
+    // from the list. Eg. If the list contains [A, B, C], and now the last
+    // element C is the main controller. When B becomes main controller later,
+    // the list would become [A, C, B]. And if A becomes main controller, list
+    // would become [C, B, A]. Then, if we remove A from the list, the next main
+    // controller would be B. But if we don't maintain the controller order when
+    // main controller changes, we would pick C as the main controller because
+    // the list is still [A, B, C].
+    return mControllers.insertBack(aController);
+  }
+
+  MOZ_ASSERT(aOption == InsertOptions::eInsertAsNormalController);
+  MOZ_ASSERT(GetMainController() != aController);
+  // We might have multiple controllers which have higher priority (being used
+  // in PIP or fullscreen) from the head, the normal controller should be
+  // inserted before them. Therefore, search a higher priority controller from
+  // the head and insert new controller before it.
+  // Eg. a list [A, B, C, D, E] and D and E have higher priority, if we want
+  // to insert F, then the final result would be [A, B, C, F, D, E]
+  auto* current = static_cast<LinkedListControllerPtr>(mControllers.getFirst());
+  while (!static_cast<MediaController*>(current)
+              ->IsBeingUsedInPIPModeOrFullscreen()) {
+    current = current->getNext();
+  }
+  MOZ_ASSERT(current, "Should have at least one higher priority controller!");
+  current->setPrevious(aController);
+}
+
+void MediaControlService::ControllerManager::Shutdown() {
+  mControllers.clear();
+  DisconnectMainControllerEvents();
+}
+
+void MediaControlService::ControllerManager::MainControllerPlaybackStateChanged(
+    MediaSessionPlaybackState aState) {
+  MOZ_ASSERT(NS_IsMainThread());
+  mSource->SetPlaybackState(aState);
+}
+
+void MediaControlService::ControllerManager::MainControllerMetadataChanged(
+    const MediaMetadataBase& aMetadata) {
+  MOZ_ASSERT(NS_IsMainThread());
+  mSource->SetMediaMetadata(aMetadata);
+}
+
+void MediaControlService::ControllerManager::UpdateMainControllerInternal(
+    MediaController* aController) {
+  MOZ_ASSERT(NS_IsMainThread());
+  if (aController) {
+    aController->Select();
+  }
+  if (mMainController) {
+    mMainController->Unselect();
+  }
+  mMainController = aController;
+
+  if (!mMainController) {
+    LOG_MAINCONTROLLER_INFO("Clear main controller");
+    mSource->Close();
+    DisconnectMainControllerEvents();
+  } else {
+    LOG_MAINCONTROLLER_INFO("Set controller %" PRId64 " as main controller",
+                            mMainController->Id());
+    if (!mSource->Open()) {
+      LOG("Failed to open source for monitoring media keys");
+    }
+    // We would still update those status to the event source even if it failed
+    // to open, because it would save the result and set them to the real
+    // source when it opens. In addition, another benefit to do that is to
+    // prevent testing from affecting by platform specific issues, because our
+    // testing events rely on those status changes and they are all platform
+    // independent.
+    mSource->SetPlaybackState(mMainController->PlaybackState());
+    mSource->SetMediaMetadata(mMainController->GetCurrentMediaMetadata());
+    mSource->SetSupportedMediaKeys(mMainController->GetSupportedMediaKeys());
+    ConnectMainControllerEvents();
+  }
+
+  if (StaticPrefs::media_mediacontrol_testingevents_enabled()) {
+    if (nsCOMPtr<nsIObserverService> obs = services::GetObserverService()) {
+      obs->NotifyObservers(nullptr, "main-media-controller-changed", nullptr);
+    }
+  }
+}
+
+void MediaControlService::ControllerManager::ConnectMainControllerEvents() {
+  // As main controller has been changed, we should disconnect listeners from
+  // the previous controller and reconnect them to the new controller.
+  DisconnectMainControllerEvents();
+  // Listen to main controller's event in order to propagate the content that
+  // might be displayed on the virtual control interface created by the source.
+  mMetadataChangedListener = mMainController->MetadataChangedEvent().Connect(
+      AbstractThread::MainThread(), this,
+      &ControllerManager::MainControllerMetadataChanged);
+  mSupportedKeysChangedListener =
+      mMainController->SupportedKeysChangedEvent().Connect(
+          AbstractThread::MainThread(),
+          [this](const MediaKeysArray& aSupportedKeys) {
+            mSource->SetSupportedMediaKeys(aSupportedKeys);
+          });
+  mFullScreenChangedListener =
+      mMainController->FullScreenChangedEvent().Connect(
+          AbstractThread::MainThread(), [this](bool aIsEnabled) {
+            mSource->SetEnableFullScreen(aIsEnabled);
+          });
+  mPictureInPictureModeChangedListener =
+      mMainController->PictureInPictureModeChangedEvent().Connect(
+          AbstractThread::MainThread(), [this](bool aIsEnabled) {
+            mSource->SetEnablePictureInPictureMode(aIsEnabled);
+          });
+  mPositionChangedListener = mMainController->PositionChangedEvent().Connect(
+      AbstractThread::MainThread(), [this](const PositionState& aState) {
+        mSource->SetPositionState(aState);
+      });
+}
+
+void MediaControlService::ControllerManager::DisconnectMainControllerEvents() {
+  mMetadataChangedListener.DisconnectIfExists();
+  mSupportedKeysChangedListener.DisconnectIfExists();
+  mFullScreenChangedListener.DisconnectIfExists();
+  mPictureInPictureModeChangedListener.DisconnectIfExists();
+  mPositionChangedListener.DisconnectIfExists();
+}
+
+MediaController* MediaControlService::ControllerManager::GetMainController()
+    const {
+  return mMainController.get();
+}
+
+uint64_t MediaControlService::ControllerManager::GetControllersNum() const {
+  return mControllers.length();
+}
+
+bool MediaControlService::ControllerManager::Contains(
+    MediaController* aController) const {
+  return mControllers.contains(aController);
+}
+
+}  // namespace mozilla::dom
diff --git a/dom/media/mediacontrol/MediaControlService.h b/dom/media/mediacontrol/MediaControlService.h
new file mode 100644
index 0000000000..d0112ffe3c
--- /dev/null
+++ b/dom/media/mediacontrol/MediaControlService.h
@@ -0,0 +1,181 @@
+/* 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 DOM_MEDIA_MEDIACONTROL_MEDIACONTROLSERVICE_H_
+#define DOM_MEDIA_MEDIACONTROL_MEDIACONTROLSERVICE_H_
+
+#include "mozilla/AlreadyAddRefed.h"
+
+#include "AudioFocusManager.h"
+#include "MediaController.h"
+#include "MediaControlKeyManager.h"
+#include "mozilla/dom/MediaControllerBinding.h"
+#include "nsIObserver.h"
+#include "nsTArray.h"
+
+namespace mozilla::dom {
+
+/**
+ * MediaControlService is an interface to access controllers by providing
+ * controller Id. Everytime when controller becomes active, which means there is
+ * one or more media started in the corresponding browsing context, so now the
+ * controller is actually controlling something in the content process, so it
+ * would be added into the list of the MediaControlService. The controller would
+ * be removed from the list of the MediaControlService when it becomes inactive,
+ * which means no media is playing in the corresponding browsing context. Note
+ * that, a controller can't be added to or remove from the list twice. It should
+ * should have a responsibility to add and remove itself in the proper time.
+ */
+class MediaControlService final : public nsIObserver {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIOBSERVER
+
+  static RefPtr<MediaControlService> GetService();
+
+  // Currently these following static methods are only being used in testing.
+  static void GenerateMediaControlKey(const GlobalObject& global,
+                                      MediaControlKey aKey);
+  static void GetCurrentActiveMediaMetadata(const GlobalObject& aGlobal,
+                                            MediaMetadataInit& aMetadata);
+  static MediaSessionPlaybackState GetCurrentMediaSessionPlaybackState(
+      GlobalObject& aGlobal);
+
+  AudioFocusManager& GetAudioFocusManager() { return mAudioFocusManager; }
+  MediaControlKeySource* GetMediaControlKeySource() {
+    return mMediaControlKeyManager;
+  }
+
+  // Use these functions to register/unresgister controller to/from the active
+  // controller list in the service. Return true if the controller is registered
+  // or unregistered sucessfully.
+  bool RegisterActiveMediaController(MediaController* aController);
+  bool UnregisterActiveMediaController(MediaController* aController);
+  uint64_t GetActiveControllersNum() const;
+
+  // This method would be called when the controller changes its playback state.
+  void NotifyControllerPlaybackStateChanged(MediaController* aController);
+
+  // This method is used to help a media controller become a main controller, if
+  // it fits the requirement.
+  void RequestUpdateMainController(MediaController* aController);
+
+  // The main controller is the controller which can receive the media control
+  // key events and would show its metadata to virtual controller interface.
+  MediaController* GetMainController() const;
+
+  /**
+   * These following functions are used for testing only. We use them to
+   * generate fake media control key events, get the media metadata and playback
+   * state from the main controller.
+   */
+  void GenerateTestMediaControlKey(MediaControlKey aKey);
+  MediaMetadataBase GetMainControllerMediaMetadata() const;
+  MediaSessionPlaybackState GetMainControllerPlaybackState() const;
+
+  // Media title that should be used as a fallback. This commonly used
+  // when playing media in private browsing mode and we are trying to avoid
+  // exposing potentially sensitive titles.
+  nsString GetFallbackTitle() const;
+
+  // These functions are used to update the variable which would be used for
+  // telemetry probe.
+  void NotifyMediaControlHasEverBeenUsed();
+  void NotifyMediaControlHasEverBeenEnabled();
+
+ private:
+  MediaControlService();
+  ~MediaControlService();
+
+  /**
+   * When there are multiple media controllers existing, we would only choose
+   * one media controller as the main controller which can be controlled by
+   * media control keys event. The latest controller which is added into the
+   * service would become the main controller.
+   *
+   * However, as the main controller would be changed from time to time, so we
+   * create this wrapper to hold a real main controller if it exists. This class
+   * would also observe the playback state of controller in order to update the
+   * playback state of the event source.
+   *
+   * In addition, after finishing bug1592037, we would get the media metadata
+   * from the main controller, and update them to the event source in order to
+   * show those information on the virtual media controller interface on each
+   * platform.
+   */
+  class ControllerManager final {
+   public:
+    explicit ControllerManager(MediaControlService* aService);
+    ~ControllerManager() = default;
+
+    using MediaKeysArray = nsTArray<MediaControlKey>;
+    using LinkedListControllerPtr = LinkedListElement<RefPtr<MediaController>>*;
+    using ConstLinkedListControllerPtr =
+        const LinkedListElement<RefPtr<MediaController>>*;
+
+    bool AddController(MediaController* aController);
+    bool RemoveController(MediaController* aController);
+    void UpdateMainControllerIfNeeded(MediaController* aController);
+
+    void Shutdown();
+
+    MediaController* GetMainController() const;
+    bool Contains(MediaController* aController) const;
+    uint64_t GetControllersNum() const;
+
+    // These functions are used for monitoring main controller's status change.
+    void MainControllerPlaybackStateChanged(MediaSessionPlaybackState aState);
+    void MainControllerMetadataChanged(const MediaMetadataBase& aMetadata);
+
+   private:
+    // When applying `eInsertAsMainController`, we would always insert the
+    // element to the tail of the list. Eg. Insert C , [A, B] -> [A, B, C]
+    // When applying `eInsertAsNormalController`, we would insert the element
+    // prior to the element with a higher priority controller. Eg. Insert E and
+    // C and D have higher priority. [A, B, C, D] -> [A, B, E, C, D]
+    enum class InsertOptions {
+      eInsertAsMainController,
+      eInsertAsNormalController,
+    };
+
+    // Adjust the given controller's order by the insert option.
+    void ReorderGivenController(MediaController* aController,
+                                InsertOptions aOption);
+
+    void UpdateMainControllerInternal(MediaController* aController);
+    void ConnectMainControllerEvents();
+    void DisconnectMainControllerEvents();
+
+    LinkedList<RefPtr<MediaController>> mControllers;
+    RefPtr<MediaController> mMainController;
+
+    // These member are use to listen main controller's play state changes and
+    // update the playback state to the event source.
+    RefPtr<MediaControlKeySource> mSource;
+    MediaEventListener mMetadataChangedListener;
+    MediaEventListener mSupportedKeysChangedListener;
+    MediaEventListener mFullScreenChangedListener;
+    MediaEventListener mPictureInPictureModeChangedListener;
+    MediaEventListener mPositionChangedListener;
+  };
+
+  void Init();
+  void Shutdown();
+
+  AudioFocusManager mAudioFocusManager;
+  RefPtr<MediaControlKeyManager> mMediaControlKeyManager;
+  RefPtr<MediaControlKeyListener> mMediaKeysHandler;
+  MediaEventProducer<uint64_t> mMediaControllerAmountChangedEvent;
+  UniquePtr<ControllerManager> mControllerManager;
+  nsString mFallbackTitle;
+
+  // Used for telemetry probe.
+  void UpdateTelemetryUsageProbe();
+  bool mHasEverUsedMediaControl = false;
+  bool mHasEverEnabledMediaControl = false;
+};
+
+}  // namespace mozilla::dom
+
+#endif
diff --git a/dom/media/mediacontrol/MediaControlUtils.cpp b/dom/media/mediacontrol/MediaControlUtils.cpp
new file mode 100644
index 0000000000..090844e47c
--- /dev/null
+++ b/dom/media/mediacontrol/MediaControlUtils.cpp
@@ -0,0 +1,26 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#include "MediaControlUtils.h"
+
+#include "mozilla/dom/BrowsingContext.h"
+
+mozilla::LazyLogModule gMediaControlLog("MediaControl");
+
+namespace mozilla::dom {
+
+BrowsingContext* GetAliveTopBrowsingContext(BrowsingContext* aBC) {
+  if (!aBC || aBC->IsDiscarded()) {
+    return nullptr;
+  }
+  aBC = aBC->Top();
+  if (!aBC || aBC->IsDiscarded()) {
+    return nullptr;
+  }
+  return aBC;
+}
+
+}  // namespace mozilla::dom
diff --git a/dom/media/mediacontrol/MediaControlUtils.h b/dom/media/mediacontrol/MediaControlUtils.h
new file mode 100644
index 0000000000..a327c2f3d8
--- /dev/null
+++ b/dom/media/mediacontrol/MediaControlUtils.h
@@ -0,0 +1,216 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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 DOM_MEDIA_MEDIACONTROL_MEDIACONTROLUTILS_H_
+#define DOM_MEDIA_MEDIACONTROL_MEDIACONTROLUTILS_H_
+
+#include "imgIEncoder.h"
+#include "imgITools.h"
+#include "MediaController.h"
+#include "mozilla/dom/ChromeUtilsBinding.h"
+#include "mozilla/dom/MediaControllerBinding.h"
+#include "mozilla/Logging.h"
+#include "nsReadableUtils.h"
+#include "nsServiceManagerUtils.h"
+
+extern mozilla::LazyLogModule gMediaControlLog;
+
+namespace mozilla::dom {
+
+inline const char* ToMediaControlKeyStr(MediaControlKey aKey) {
+  switch (aKey) {
+    case MediaControlKey::Focus:
+      return "Focus";
+    case MediaControlKey::Pause:
+      return "Pause";
+    case MediaControlKey::Play:
+      return "Play";
+    case MediaControlKey::Playpause:
+      return "Play & pause";
+    case MediaControlKey::Previoustrack:
+      return "Previous track";
+    case MediaControlKey::Nexttrack:
+      return "Next track";
+    case MediaControlKey::Seekbackward:
+      return "Seek backward";
+    case MediaControlKey::Seekforward:
+      return "Seek forward";
+    case MediaControlKey::Skipad:
+      return "Skip Ad";
+    case MediaControlKey::Seekto:
+      return "Seek to";
+    case MediaControlKey::Stop:
+      return "Stop";
+    default:
+      MOZ_ASSERT_UNREACHABLE("Invalid action.");
+      return "Unknown";
+  }
+}
+
+inline const char* ToMediaSessionActionStr(MediaSessionAction aAction) {
+  switch (aAction) {
+    case MediaSessionAction::Play:
+      return "play";
+    case MediaSessionAction::Pause:
+      return "pause";
+    case MediaSessionAction::Seekbackward:
+      return "seek backward";
+    case MediaSessionAction::Seekforward:
+      return "seek forward";
+    case MediaSessionAction::Previoustrack:
+      return "previous track";
+    case MediaSessionAction::Nexttrack:
+      return "next track";
+    case MediaSessionAction::Skipad:
+      return "skip ad";
+    case MediaSessionAction::Seekto:
+      return "Seek to";
+    default:
+      MOZ_ASSERT(aAction == MediaSessionAction::Stop);
+      return "stop";
+  }
+}
+
+inline MediaControlKey ConvertMediaSessionActionToControlKey(
+    MediaSessionAction aAction) {
+  switch (aAction) {
+    case MediaSessionAction::Play:
+      return MediaControlKey::Play;
+    case MediaSessionAction::Pause:
+      return MediaControlKey::Pause;
+    case MediaSessionAction::Seekbackward:
+      return MediaControlKey::Seekbackward;
+    case MediaSessionAction::Seekforward:
+      return MediaControlKey::Seekforward;
+    case MediaSessionAction::Previoustrack:
+      return MediaControlKey::Previoustrack;
+    case MediaSessionAction::Nexttrack:
+      return MediaControlKey::Nexttrack;
+    case MediaSessionAction::Skipad:
+      return MediaControlKey::Skipad;
+    case MediaSessionAction::Seekto:
+      return MediaControlKey::Seekto;
+    default:
+      MOZ_ASSERT(aAction == MediaSessionAction::Stop);
+      return MediaControlKey::Stop;
+  }
+}
+
+inline MediaSessionAction ConvertToMediaSessionAction(uint8_t aActionValue) {
+  MOZ_DIAGNOSTIC_ASSERT(aActionValue < uint8_t(MediaSessionAction::EndGuard_));
+  return static_cast<MediaSessionAction>(aActionValue);
+}
+
+inline const char* ToMediaPlaybackStateStr(MediaPlaybackState aState) {
+  switch (aState) {
+    case MediaPlaybackState::eStarted:
+      return "started";
+    case MediaPlaybackState::ePlayed:
+      return "played";
+    case MediaPlaybackState::ePaused:
+      return "paused";
+    case MediaPlaybackState::eStopped:
+      return "stopped";
+    default:
+      MOZ_ASSERT_UNREACHABLE("Invalid media state.");
+      return "Unknown";
+  }
+}
+
+inline const char* ToMediaAudibleStateStr(MediaAudibleState aState) {
+  switch (aState) {
+    case MediaAudibleState::eInaudible:
+      return "inaudible";
+    case MediaAudibleState::eAudible:
+      return "audible";
+    default:
+      MOZ_ASSERT_UNREACHABLE("Invalid audible state.");
+      return "Unknown";
+  }
+}
+
+inline const char* ToMediaSessionPlaybackStateStr(
+    const MediaSessionPlaybackState& aState) {
+  switch (aState) {
+    case MediaSessionPlaybackState::None:
+      return "none";
+    case MediaSessionPlaybackState::Paused:
+      return "paused";
+    case MediaSessionPlaybackState::Playing:
+      return "playing";
+    default:
+      MOZ_ASSERT_UNREACHABLE("Invalid MediaSessionPlaybackState.");
+      return "Unknown";
+  }
+}
+
+BrowsingContext* GetAliveTopBrowsingContext(BrowsingContext* aBC);
+
+inline bool IsImageIn(const nsTArray<MediaImage>& aArtwork,
+                      const nsAString& aImageUrl) {
+  for (const MediaImage& image : aArtwork) {
+    if (image.mSrc == aImageUrl) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// The image buffer would be allocated in aStream whose size is aSize and the
+// buffer head is aBuffer
+inline nsresult GetEncodedImageBuffer(imgIContainer* aImage,
+                                      const nsACString& aMimeType,
+                                      nsIInputStream** aStream, uint32_t* aSize,
+                                      char** aBuffer) {
+  MOZ_ASSERT(aImage);
+
+  nsCOMPtr<imgITools> imgTools = do_GetService("@mozilla.org/image/tools;1");
+  if (!imgTools) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsCOMPtr<nsIInputStream> inputStream;
+  nsresult rv = imgTools->EncodeImage(aImage, aMimeType, u""_ns,
+                                      getter_AddRefs(inputStream));
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  if (!inputStream) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsCOMPtr<imgIEncoder> encoder = do_QueryInterface(inputStream);
+  if (!encoder) {
+    return NS_ERROR_FAILURE;
+  }
+
+  rv = encoder->GetImageBufferUsed(aSize);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  rv = encoder->GetImageBuffer(aBuffer);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  encoder.forget(aStream);
+  return NS_OK;
+}
+
+inline bool IsValidImageUrl(const nsAString& aUrl) {
+  return StringBeginsWith(aUrl, u"http://"_ns) ||
+         StringBeginsWith(aUrl, u"https://"_ns);
+}
+
+inline uint32_t GetMediaKeyMask(mozilla::dom::MediaControlKey aKey) {
+  return 1 << static_cast<uint8_t>(aKey);
+}
+
+}  // namespace mozilla::dom
+
+#endif  // DOM_MEDIA_MEDIACONTROL_MEDIACONTROLUTILS_H_
diff --git a/dom/media/mediacontrol/MediaController.cpp b/dom/media/mediacontrol/MediaController.cpp
new file mode 100644
index 0000000000..b06635091d
--- /dev/null
+++ b/dom/media/mediacontrol/MediaController.cpp
@@ -0,0 +1,560 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#include "MediaController.h"
+
+#include "MediaControlService.h"
+#include "MediaControlUtils.h"
+#include "MediaControlKeySource.h"
+#include "mozilla/AsyncEventDispatcher.h"
+#include "mozilla/StaticPrefs_media.h"
+#include "mozilla/dom/BrowsingContext.h"
+#include "mozilla/dom/CanonicalBrowsingContext.h"
+#include "mozilla/dom/MediaSession.h"
+#include "mozilla/dom/PositionStateEvent.h"
+
+// avoid redefined macro in unified build
+#undef LOG
+#define LOG(msg, ...)                                                    \
+  MOZ_LOG(gMediaControlLog, LogLevel::Debug,                             \
+          ("MediaController=%p, Id=%" PRId64 ", " msg, this, this->Id(), \
+           ##__VA_ARGS__))
+
+namespace mozilla::dom {
+
+NS_IMPL_CYCLE_COLLECTION_INHERITED(MediaController, DOMEventTargetHelper)
+NS_IMPL_ISUPPORTS_CYCLE_COLLECTION_INHERITED(MediaController,
+                                             DOMEventTargetHelper,
+                                             nsITimerCallback, nsINamed)
+NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(MediaController,
+                                               DOMEventTargetHelper)
+NS_IMPL_CYCLE_COLLECTION_TRACE_END
+
+nsISupports* MediaController::GetParentObject() const {
+  RefPtr<BrowsingContext> bc = BrowsingContext::Get(Id());
+  return bc;
+}
+
+JSObject* MediaController::WrapObject(JSContext* aCx,
+                                      JS::Handle<JSObject*> aGivenProto) {
+  return MediaController_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+void MediaController::GetSupportedKeys(
+    nsTArray<MediaControlKey>& aRetVal) const {
+  aRetVal.Clear();
+  for (const auto& key : mSupportedKeys) {
+    aRetVal.AppendElement(key);
+  }
+}
+
+void MediaController::GetMetadata(MediaMetadataInit& aMetadata,
+                                  ErrorResult& aRv) {
+  if (!IsActive() || mShutdown) {
+    aRv.Throw(NS_ERROR_NOT_AVAILABLE);
+    return;
+  }
+
+  const MediaMetadataBase metadata = GetCurrentMediaMetadata();
+  aMetadata.mTitle = metadata.mTitle;
+  aMetadata.mArtist = metadata.mArtist;
+  aMetadata.mAlbum = metadata.mAlbum;
+  for (const auto& artwork : metadata.mArtwork) {
+    if (MediaImage* image = aMetadata.mArtwork.AppendElement(fallible)) {
+      image->mSrc = artwork.mSrc;
+      image->mSizes = artwork.mSizes;
+      image->mType = artwork.mType;
+    } else {
+      aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
+      return;
+    }
+  }
+}
+
+static const MediaControlKey sDefaultSupportedKeys[] = {
+    MediaControlKey::Focus,     MediaControlKey::Play, MediaControlKey::Pause,
+    MediaControlKey::Playpause, MediaControlKey::Stop,
+};
+
+static void GetDefaultSupportedKeys(nsTArray<MediaControlKey>& aKeys) {
+  for (const auto& key : sDefaultSupportedKeys) {
+    aKeys.AppendElement(key);
+  }
+}
+
+MediaController::MediaController(uint64_t aBrowsingContextId)
+    : MediaStatusManager(aBrowsingContextId) {
+  MOZ_DIAGNOSTIC_ASSERT(XRE_IsParentProcess(),
+                        "MediaController only runs on Chrome process!");
+  LOG("Create controller %" PRId64, Id());
+  GetDefaultSupportedKeys(mSupportedKeys);
+  mSupportedActionsChangedListener = SupportedActionsChangedEvent().Connect(
+      AbstractThread::MainThread(), this,
+      &MediaController::HandleSupportedMediaSessionActionsChanged);
+  mPlaybackChangedListener = PlaybackChangedEvent().Connect(
+      AbstractThread::MainThread(), this,
+      &MediaController::HandleActualPlaybackStateChanged);
+  mPositionStateChangedListener = PositionChangedEvent().Connect(
+      AbstractThread::MainThread(), this,
+      &MediaController::HandlePositionStateChanged);
+  mMetadataChangedListener =
+      MetadataChangedEvent().Connect(AbstractThread::MainThread(), this,
+                                     &MediaController::HandleMetadataChanged);
+}
+
+MediaController::~MediaController() {
+  LOG("Destroy controller %" PRId64, Id());
+  if (!mShutdown) {
+    Shutdown();
+  }
+};
+
+void MediaController::Focus() {
+  LOG("Focus");
+  UpdateMediaControlActionToContentMediaIfNeeded(
+      MediaControlAction(MediaControlKey::Focus));
+}
+
+void MediaController::Play() {
+  LOG("Play");
+  UpdateMediaControlActionToContentMediaIfNeeded(
+      MediaControlAction(MediaControlKey::Play));
+}
+
+void MediaController::Pause() {
+  LOG("Pause");
+  UpdateMediaControlActionToContentMediaIfNeeded(
+      MediaControlAction(MediaControlKey::Pause));
+}
+
+void MediaController::PrevTrack() {
+  LOG("Prev Track");
+  UpdateMediaControlActionToContentMediaIfNeeded(
+      MediaControlAction(MediaControlKey::Previoustrack));
+}
+
+void MediaController::NextTrack() {
+  LOG("Next Track");
+  UpdateMediaControlActionToContentMediaIfNeeded(
+      MediaControlAction(MediaControlKey::Nexttrack));
+}
+
+void MediaController::SeekBackward() {
+  LOG("Seek Backward");
+  UpdateMediaControlActionToContentMediaIfNeeded(
+      MediaControlAction(MediaControlKey::Seekbackward));
+}
+
+void MediaController::SeekForward() {
+  LOG("Seek Forward");
+  UpdateMediaControlActionToContentMediaIfNeeded(
+      MediaControlAction(MediaControlKey::Seekforward));
+}
+
+void MediaController::SkipAd() {
+  LOG("Skip Ad");
+  UpdateMediaControlActionToContentMediaIfNeeded(
+      MediaControlAction(MediaControlKey::Skipad));
+}
+
+void MediaController::SeekTo(double aSeekTime, bool aFastSeek) {
+  LOG("Seek To");
+  UpdateMediaControlActionToContentMediaIfNeeded(MediaControlAction(
+      MediaControlKey::Seekto, SeekDetails(aSeekTime, aFastSeek)));
+}
+
+void MediaController::Stop() {
+  LOG("Stop");
+  UpdateMediaControlActionToContentMediaIfNeeded(
+      MediaControlAction(MediaControlKey::Stop));
+  MediaStatusManager::ClearActiveMediaSessionContextIdIfNeeded();
+}
+
+uint64_t MediaController::Id() const { return mTopLevelBrowsingContextId; }
+
+bool MediaController::IsAudible() const { return IsMediaAudible(); }
+
+bool MediaController::IsPlaying() const { return IsMediaPlaying(); }
+
+bool MediaController::IsActive() const { return mIsActive; };
+
+bool MediaController::ShouldPropagateActionToAllContexts(
+    const MediaControlAction& aAction) const {
+  // These three actions have default action handler for each frame, so we
+  // need to propagate to all contexts. We would handle default handlers in
+  // `ContentMediaController::HandleMediaKey`.
+  return aAction.mKey == MediaControlKey::Play ||
+         aAction.mKey == MediaControlKey::Pause ||
+         aAction.mKey == MediaControlKey::Stop;
+}
+
+void MediaController::UpdateMediaControlActionToContentMediaIfNeeded(
+    const MediaControlAction& aAction) {
+  // If the controller isn't active or it has been shutdown, we don't need to
+  // update media action to the content process.
+  if (!mIsActive || mShutdown) {
+    return;
+  }
+
+  // For some actions which have default action handler, we want to propagate
+  // them on all contexts in order to trigger the default handler on each
+  // context separately. Otherwise, other action should only be propagated to
+  // the context where active media session exists.
+  const bool propateToAll = ShouldPropagateActionToAllContexts(aAction);
+  const uint64_t targetContextId = propateToAll || !mActiveMediaSessionContextId
+                                       ? Id()
+                                       : *mActiveMediaSessionContextId;
+  RefPtr<BrowsingContext> context = BrowsingContext::Get(targetContextId);
+  if (!context || context->IsDiscarded()) {
+    return;
+  }
+
+  if (propateToAll) {
+    context->PreOrderWalk([&](BrowsingContext* bc) {
+      bc->Canonical()->UpdateMediaControlAction(aAction);
+    });
+  } else {
+    context->Canonical()->UpdateMediaControlAction(aAction);
+  }
+  RefPtr<MediaControlService> service = MediaControlService::GetService();
+  MOZ_ASSERT(service);
+  service->NotifyMediaControlHasEverBeenUsed();
+}
+
+void MediaController::Shutdown() {
+  MOZ_ASSERT(!mShutdown, "Do not call shutdown twice!");
+  // The media controller would be removed from the service when we receive a
+  // notification from the content process about all controlled media has been
+  // stoppped. However, if controlled media is stopped after detaching
+  // browsing context, then sending the notification from the content process
+  // would fail so that we are not able to notify the chrome process to remove
+  // the corresponding controller. Therefore, we should manually remove the
+  // controller from the service.
+  Deactivate();
+  mShutdown = true;
+  mSupportedActionsChangedListener.DisconnectIfExists();
+  mPlaybackChangedListener.DisconnectIfExists();
+  mPositionStateChangedListener.DisconnectIfExists();
+  mMetadataChangedListener.DisconnectIfExists();
+}
+
+void MediaController::NotifyMediaPlaybackChanged(uint64_t aBrowsingContextId,
+                                                 MediaPlaybackState aState) {
+  if (mShutdown) {
+    return;
+  }
+  MediaStatusManager::NotifyMediaPlaybackChanged(aBrowsingContextId, aState);
+  UpdateDeactivationTimerIfNeeded();
+  UpdateActivatedStateIfNeeded();
+}
+
+void MediaController::UpdateDeactivationTimerIfNeeded() {
+  if (!StaticPrefs::media_mediacontrol_stopcontrol_timer()) {
+    return;
+  }
+
+  bool shouldBeAlwaysActive = IsPlaying() || IsBeingUsedInPIPModeOrFullscreen();
+  if (shouldBeAlwaysActive && mDeactivationTimer) {
+    LOG("Cancel deactivation timer");
+    mDeactivationTimer->Cancel();
+    mDeactivationTimer = nullptr;
+  } else if (!shouldBeAlwaysActive && !mDeactivationTimer) {
+    nsresult rv = NS_NewTimerWithCallback(
+        getter_AddRefs(mDeactivationTimer), this,
+        StaticPrefs::media_mediacontrol_stopcontrol_timer_ms(),
+        nsITimer::TYPE_ONE_SHOT, AbstractThread::MainThread());
+    if (NS_SUCCEEDED(rv)) {
+      LOG("Create a deactivation timer");
+    } else {
+      LOG("Failed to create a deactivation timer");
+    }
+  }
+}
+
+bool MediaController::IsBeingUsedInPIPModeOrFullscreen() const {
+  return mIsInPictureInPictureMode || mIsInFullScreenMode;
+}
+
+NS_IMETHODIMP MediaController::Notify(nsITimer* aTimer) {
+  mDeactivationTimer = nullptr;
+  if (!StaticPrefs::media_mediacontrol_stopcontrol_timer()) {
+    return NS_OK;
+  }
+
+  if (mShutdown) {
+    LOG("Cancel deactivation timer because controller has been shutdown");
+    return NS_OK;
+  }
+
+  // As the media being used in the PIP mode or fullscreen would always display
+  // on the screen, users would have high chance to interact with it again, so
+  // we don't want to stop media control.
+  if (IsBeingUsedInPIPModeOrFullscreen()) {
+    LOG("Cancel deactivation timer because controller is in PIP mode");
+    return NS_OK;
+  }
+
+  if (IsPlaying()) {
+    LOG("Cancel deactivation timer because controller is still playing");
+    return NS_OK;
+  }
+
+  if (!mIsActive) {
+    LOG("Cancel deactivation timer because controller has been deactivated");
+    return NS_OK;
+  }
+  Deactivate();
+  return NS_OK;
+}
+
+NS_IMETHODIMP MediaController::GetName(nsACString& aName) {
+  aName.AssignLiteral("MediaController");
+  return NS_OK;
+}
+
+void MediaController::NotifyMediaAudibleChanged(uint64_t aBrowsingContextId,
+                                                MediaAudibleState aState) {
+  if (mShutdown) {
+    return;
+  }
+
+  bool oldAudible = IsAudible();
+  MediaStatusManager::NotifyMediaAudibleChanged(aBrowsingContextId, aState);
+  if (IsAudible() == oldAudible) {
+    return;
+  }
+  UpdateActivatedStateIfNeeded();
+
+  // Request the audio focus amongs different controllers that could cause
+  // pausing other audible controllers if we enable the audio focus management.
+  RefPtr<MediaControlService> service = MediaControlService::GetService();
+  MOZ_ASSERT(service);
+  if (IsAudible()) {
+    service->GetAudioFocusManager().RequestAudioFocus(this);
+  } else {
+    service->GetAudioFocusManager().RevokeAudioFocus(this);
+  }
+}
+
+bool MediaController::ShouldActivateController() const {
+  MOZ_ASSERT(!mShutdown);
+  // After media is successfully loaded and match our critiera, such as its
+  // duration is longer enough, which is used to exclude the notification-ish
+  // sound, then it would be able to be controlled once the controll gets
+  // activated.
+  //
+  // Activating a controller means that we would start to intercept the media
+  // keys on the platform and show the virtual control interface (if needed).
+  // The controller would be activated when (1) controllable media starts in the
+  // browsing context that controller belongs to (2) controllable media enters
+  // fullscreen or PIP mode.
+  return IsAnyMediaBeingControlled() &&
+         (IsPlaying() || IsBeingUsedInPIPModeOrFullscreen()) && !mIsActive;
+}
+
+bool MediaController::ShouldDeactivateController() const {
+  MOZ_ASSERT(!mShutdown);
+  // If we don't have an active media session and no controlled media exists,
+  // then we don't need to keep controller active, because there is nothing to
+  // control. However, if we still have an active media session, then we should
+  // keep controller active in order to receive media keys even if we don't have
+  // any controlled media existing, because a website might start other media
+  // when media session receives media keys.
+  return !IsAnyMediaBeingControlled() && mIsActive &&
+         !mActiveMediaSessionContextId;
+}
+
+void MediaController::Activate() {
+  MOZ_ASSERT(!mShutdown);
+  RefPtr<MediaControlService> service = MediaControlService::GetService();
+  if (service && !mIsActive) {
+    LOG("Activate");
+    mIsActive = service->RegisterActiveMediaController(this);
+    MOZ_ASSERT(mIsActive, "Fail to register controller!");
+    DispatchAsyncEvent(u"activated"_ns);
+  }
+}
+
+void MediaController::Deactivate() {
+  MOZ_ASSERT(!mShutdown);
+  RefPtr<MediaControlService> service = MediaControlService::GetService();
+  if (service) {
+    service->GetAudioFocusManager().RevokeAudioFocus(this);
+    if (mIsActive) {
+      LOG("Deactivate");
+      mIsActive = !service->UnregisterActiveMediaController(this);
+      MOZ_ASSERT(!mIsActive, "Fail to unregister controller!");
+      DispatchAsyncEvent(u"deactivated"_ns);
+    }
+  }
+}
+
+void MediaController::SetIsInPictureInPictureMode(
+    uint64_t aBrowsingContextId, bool aIsInPictureInPictureMode) {
+  if (mIsInPictureInPictureMode == aIsInPictureInPictureMode) {
+    return;
+  }
+  LOG("Set IsInPictureInPictureMode to %s",
+      aIsInPictureInPictureMode ? "true" : "false");
+  mIsInPictureInPictureMode = aIsInPictureInPictureMode;
+  ForceToBecomeMainControllerIfNeeded();
+  UpdateDeactivationTimerIfNeeded();
+  mPictureInPictureModeChangedEvent.Notify(mIsInPictureInPictureMode);
+}
+
+void MediaController::NotifyMediaFullScreenState(uint64_t aBrowsingContextId,
+                                                 bool aIsInFullScreen) {
+  if (mIsInFullScreenMode == aIsInFullScreen) {
+    return;
+  }
+  LOG("%s fullscreen", aIsInFullScreen ? "Entered" : "Left");
+  mIsInFullScreenMode = aIsInFullScreen;
+  ForceToBecomeMainControllerIfNeeded();
+  mFullScreenChangedEvent.Notify(mIsInFullScreenMode);
+}
+
+bool MediaController::IsMainController() const {
+  RefPtr<MediaControlService> service = MediaControlService::GetService();
+  return service ? service->GetMainController() == this : false;
+}
+
+bool MediaController::ShouldRequestForMainController() const {
+  // This controller is already the main controller.
+  if (IsMainController()) {
+    return false;
+  }
+  // We would only force controller to become main controller if it's in the
+  // PIP mode or fullscreen, otherwise it should follow the general rule.
+  // In addition, do nothing if the controller has been shutdowned.
+  return IsBeingUsedInPIPModeOrFullscreen() && !mShutdown;
+}
+
+void MediaController::ForceToBecomeMainControllerIfNeeded() {
+  if (!ShouldRequestForMainController()) {
+    return;
+  }
+  RefPtr<MediaControlService> service = MediaControlService::GetService();
+  MOZ_ASSERT(service, "service was shutdown before shutting down controller?");
+  // If the controller hasn't been activated and it's ready to be activated,
+  // then activating it should also make it become a main controller. If it's
+  // already activated but isn't a main controller yet, then explicitly request
+  // it.
+  if (!IsActive() && ShouldActivateController()) {
+    Activate();
+  } else if (IsActive()) {
+    service->RequestUpdateMainController(this);
+  }
+}
+
+void MediaController::HandleActualPlaybackStateChanged() {
+  // Media control service would like to know all controllers' playback state
+  // in order to decide which controller should be the main controller that is
+  // usually the last tab which plays media.
+  if (RefPtr<MediaControlService> service = MediaControlService::GetService()) {
+    service->NotifyControllerPlaybackStateChanged(this);
+  }
+  DispatchAsyncEvent(u"playbackstatechange"_ns);
+}
+
+void MediaController::UpdateActivatedStateIfNeeded() {
+  if (ShouldActivateController()) {
+    Activate();
+  } else if (ShouldDeactivateController()) {
+    Deactivate();
+  }
+}
+
+void MediaController::HandleSupportedMediaSessionActionsChanged(
+    const nsTArray<MediaSessionAction>& aSupportedAction) {
+  // Convert actions to keys, some of them have been included in the supported
+  // keys, such as "play", "pause" and "stop".
+  nsTArray<MediaControlKey> newSupportedKeys;
+  GetDefaultSupportedKeys(newSupportedKeys);
+  for (const auto& action : aSupportedAction) {
+    MediaControlKey key = ConvertMediaSessionActionToControlKey(action);
+    if (!newSupportedKeys.Contains(key)) {
+      newSupportedKeys.AppendElement(key);
+    }
+  }
+  // As the supported key event should only be notified when supported keys
+  // change, so abort following steps if they don't change.
+  if (newSupportedKeys == mSupportedKeys) {
+    return;
+  }
+  LOG("Supported keys changes");
+  mSupportedKeys = newSupportedKeys;
+  mSupportedKeysChangedEvent.Notify(mSupportedKeys);
+  RefPtr<AsyncEventDispatcher> asyncDispatcher = new AsyncEventDispatcher(
+      this, u"supportedkeyschange"_ns, CanBubble::eYes);
+  asyncDispatcher->PostDOMEvent();
+  MediaController_Binding::ClearCachedSupportedKeysValue(this);
+}
+
+void MediaController::HandlePositionStateChanged(const PositionState& aState) {
+  PositionStateEventInit init;
+  init.mDuration = aState.mDuration;
+  init.mPlaybackRate = aState.mPlaybackRate;
+  init.mPosition = aState.mLastReportedPlaybackPosition;
+  RefPtr<PositionStateEvent> event =
+      PositionStateEvent::Constructor(this, u"positionstatechange"_ns, init);
+  DispatchAsyncEvent(event);
+}
+
+void MediaController::HandleMetadataChanged(
+    const MediaMetadataBase& aMetadata) {
+  // The reason we don't append metadata with `metadatachange` event is that
+  // allocating artwork might fail if the memory is not enough, but for the
+  // event we are not able to throw an error. Therefore, we want to the listener
+  // to use `getMetadata()` to get metadata, because it would throw an error if
+  // we fail to allocate artwork.
+  DispatchAsyncEvent(u"metadatachange"_ns);
+  // If metadata change is because of resetting active media session, then we
+  // should check if controller needs to be deactivated.
+  if (ShouldDeactivateController()) {
+    Deactivate();
+  }
+}
+
+void MediaController::DispatchAsyncEvent(const nsAString& aName) {
+  RefPtr<Event> event = NS_NewDOMEvent(this, nullptr, nullptr);
+  event->InitEvent(aName, false, false);
+  event->SetTrusted(true);
+  DispatchAsyncEvent(event);
+}
+
+void MediaController::DispatchAsyncEvent(Event* aEvent) {
+  MOZ_ASSERT(aEvent);
+  nsAutoString eventType;
+  aEvent->GetType(eventType);
+  if (!mIsActive && !eventType.EqualsLiteral("deactivated")) {
+    LOG("Only 'deactivated' can be dispatched on a deactivated controller, not "
+        "'%s'",
+        NS_ConvertUTF16toUTF8(eventType).get());
+    return;
+  }
+  LOG("Dispatch event %s", NS_ConvertUTF16toUTF8(eventType).get());
+  RefPtr<AsyncEventDispatcher> asyncDispatcher =
+      new AsyncEventDispatcher(this, aEvent);
+  asyncDispatcher->PostDOMEvent();
+}
+
+CopyableTArray<MediaControlKey> MediaController::GetSupportedMediaKeys() const {
+  return mSupportedKeys;
+}
+
+void MediaController::Select() const {
+  if (RefPtr<BrowsingContext> bc = BrowsingContext::Get(Id())) {
+    bc->Canonical()->AddPageAwakeRequest();
+  }
+}
+
+void MediaController::Unselect() const {
+  if (RefPtr<BrowsingContext> bc = BrowsingContext::Get(Id())) {
+    bc->Canonical()->RemovePageAwakeRequest();
+  }
+}
+
+}  // namespace mozilla::dom
diff --git a/dom/media/mediacontrol/MediaController.h b/dom/media/mediacontrol/MediaController.h
new file mode 100644
index 0000000000..0f0e624f6a
--- /dev/null
+++ b/dom/media/mediacontrol/MediaController.h
@@ -0,0 +1,214 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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 DOM_MEDIA_MEDIACONTROL_MEDIACONTROLLER_H_
+#define DOM_MEDIA_MEDIACONTROL_MEDIACONTROLLER_H_
+
+#include "MediaEventSource.h"
+#include "MediaPlaybackStatus.h"
+#include "MediaStatusManager.h"
+#include "mozilla/DOMEventTargetHelper.h"
+#include "mozilla/dom/MediaControllerBinding.h"
+#include "mozilla/dom/MediaSession.h"
+#include "mozilla/LinkedList.h"
+#include "nsISupportsImpl.h"
+#include "nsITimer.h"
+
+namespace mozilla::dom {
+
+class BrowsingContext;
+
+/**
+ * IMediaController is an interface which includes control related methods and
+ * methods used to know its playback state.
+ */
+class IMediaController {
+ public:
+  NS_INLINE_DECL_PURE_VIRTUAL_REFCOUNTING
+
+  // Focus the window currently playing media.
+  virtual void Focus() = 0;
+  virtual void Play() = 0;
+  virtual void Pause() = 0;
+  virtual void Stop() = 0;
+  virtual void PrevTrack() = 0;
+  virtual void NextTrack() = 0;
+  virtual void SeekBackward() = 0;
+  virtual void SeekForward() = 0;
+  virtual void SkipAd() = 0;
+  virtual void SeekTo(double aSeekTime, bool aFastSeek) = 0;
+
+  // Return the ID of the top level browsing context within a tab.
+  virtual uint64_t Id() const = 0;
+  virtual bool IsAudible() const = 0;
+  virtual bool IsPlaying() const = 0;
+  virtual bool IsActive() const = 0;
+};
+
+/**
+ * MediaController is a class, which is used to control all media within a tab.
+ * It can only be used in Chrome process and the controlled media are usually
+ * in the content process (unless we disable e10s).
+ *
+ * Each tab would have only one media controller, they are 1-1 corresponding
+ * relationship, we use tab's top-level browsing context ID to initialize the
+ * controller and use that as its ID.
+ *
+ * The controller would be activated when its controlled media starts and
+ * becomes audible. After the controller is activated, then we can use its
+ * controlling methods, such as `Play()`, `Pause()` to control the media within
+ * the tab.
+ *
+ * If there is at least one controlled media playing in the tab, then we would
+ * say the controller is `playing`. If there is at least one controlled media is
+ * playing and audible, then we would say the controller is `audible`.
+ *
+ * Note that, if we don't enable audio competition, then we might have multiple
+ * tabs playing media at the same time, we can use the ID to query the specific
+ * controller from `MediaControlService`.
+ */
+class MediaController final : public DOMEventTargetHelper,
+                              public IMediaController,
+                              public LinkedListElement<RefPtr<MediaController>>,
+                              public MediaStatusManager,
+                              public nsITimerCallback,
+                              public nsINamed {
+ public:
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_NSITIMERCALLBACK
+  NS_DECL_NSINAMED
+  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(MediaController,
+                                                         DOMEventTargetHelper)
+  explicit MediaController(uint64_t aBrowsingContextId);
+
+  // WebIDL methods
+  nsISupports* GetParentObject() const;
+  JSObject* WrapObject(JSContext* aCx,
+                       JS::Handle<JSObject*> aGivenProto) override;
+  void GetSupportedKeys(nsTArray<MediaControlKey>& aRetVal) const;
+  void GetMetadata(MediaMetadataInit& aMetadata, ErrorResult& aRv);
+  IMPL_EVENT_HANDLER(activated);
+  IMPL_EVENT_HANDLER(deactivated);
+  IMPL_EVENT_HANDLER(metadatachange);
+  IMPL_EVENT_HANDLER(supportedkeyschange);
+  IMPL_EVENT_HANDLER(playbackstatechange);
+  IMPL_EVENT_HANDLER(positionstatechange);
+
+  // IMediaController's methods
+  void Focus() override;
+  void Play() override;
+  void Pause() override;
+  void Stop() override;
+  void PrevTrack() override;
+  void NextTrack() override;
+  void SeekBackward() override;
+  void SeekForward() override;
+  void SkipAd() override;
+  void SeekTo(double aSeekTime, bool aFastSeek) override;
+
+  uint64_t Id() const override;
+  bool IsAudible() const override;
+  bool IsPlaying() const override;
+  bool IsActive() const override;
+
+  // IMediaInfoUpdater's methods
+  void NotifyMediaPlaybackChanged(uint64_t aBrowsingContextId,
+                                  MediaPlaybackState aState) override;
+  void NotifyMediaAudibleChanged(uint64_t aBrowsingContextId,
+                                 MediaAudibleState aState) override;
+  void SetIsInPictureInPictureMode(uint64_t aBrowsingContextId,
+                                   bool aIsInPictureInPictureMode) override;
+  void NotifyMediaFullScreenState(uint64_t aBrowsingContextId,
+                                  bool aIsInFullScreen) override;
+
+  // Calling this method explicitly would mark this controller as deprecated,
+  // then calling any its method won't take any effect.
+  void Shutdown();
+
+  // This event would be notified media controller's supported media keys
+  // change.
+  MediaEventSource<nsTArray<MediaControlKey>>& SupportedKeysChangedEvent() {
+    return mSupportedKeysChangedEvent;
+  }
+
+  MediaEventSource<bool>& FullScreenChangedEvent() {
+    return mFullScreenChangedEvent;
+  }
+
+  MediaEventSource<bool>& PictureInPictureModeChangedEvent() {
+    return mPictureInPictureModeChangedEvent;
+  }
+
+  CopyableTArray<MediaControlKey> GetSupportedMediaKeys() const;
+
+  bool IsBeingUsedInPIPModeOrFullscreen() const;
+
+  // These methods are used to select/unselect the media controller as a main
+  // controller.
+  void Select() const;
+  void Unselect() const;
+
+ private:
+  ~MediaController();
+  void HandleActualPlaybackStateChanged();
+  void UpdateMediaControlActionToContentMediaIfNeeded(
+      const MediaControlAction& aAction);
+  void HandleSupportedMediaSessionActionsChanged(
+      const nsTArray<MediaSessionAction>& aSupportedAction);
+
+  void HandlePositionStateChanged(const PositionState& aState);
+  void HandleMetadataChanged(const MediaMetadataBase& aMetadata);
+
+  // This would register controller to the media control service that takes a
+  // responsibility to manage all active controllers.
+  void Activate();
+
+  // This would unregister controller from the media control service.
+  void Deactivate();
+
+  void UpdateActivatedStateIfNeeded();
+  bool ShouldActivateController() const;
+  bool ShouldDeactivateController() const;
+
+  void UpdateDeactivationTimerIfNeeded();
+
+  void DispatchAsyncEvent(const nsAString& aName);
+  void DispatchAsyncEvent(Event* aEvent);
+
+  bool IsMainController() const;
+  void ForceToBecomeMainControllerIfNeeded();
+  bool ShouldRequestForMainController() const;
+
+  bool ShouldPropagateActionToAllContexts(
+      const MediaControlAction& aAction) const;
+
+  bool mIsActive = false;
+  bool mShutdown = false;
+  bool mIsInPictureInPictureMode = false;
+  bool mIsInFullScreenMode = false;
+
+  // We would monitor the change of media session actions and convert them to
+  // the media keys, then determine the supported media keys.
+  MediaEventListener mSupportedActionsChangedListener;
+  MediaEventProducer<nsTArray<MediaControlKey>> mSupportedKeysChangedEvent;
+
+  MediaEventListener mPlaybackChangedListener;
+  MediaEventListener mPositionStateChangedListener;
+  MediaEventListener mMetadataChangedListener;
+
+  MediaEventProducer<bool> mFullScreenChangedEvent;
+  MediaEventProducer<bool> mPictureInPictureModeChangedEvent;
+  // Use copyable array so that we can use the result as a parameter for the
+  // media event.
+  CopyableTArray<MediaControlKey> mSupportedKeys;
+  // Timer to deactivate the controller if the time of being paused exceeds the
+  // threshold of time.
+  nsCOMPtr<nsITimer> mDeactivationTimer;
+};
+
+}  // namespace mozilla::dom
+
+#endif
diff --git a/dom/media/mediacontrol/MediaPlaybackStatus.cpp b/dom/media/mediacontrol/MediaPlaybackStatus.cpp
new file mode 100644
index 0000000000..80dedf8599
--- /dev/null
+++ b/dom/media/mediacontrol/MediaPlaybackStatus.cpp
@@ -0,0 +1,142 @@
+/* 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/. */
+
+#include "MediaPlaybackStatus.h"
+
+#include "MediaControlUtils.h"
+
+namespace mozilla::dom {
+
+#undef LOG
+#define LOG(msg, ...)                        \
+  MOZ_LOG(gMediaControlLog, LogLevel::Debug, \
+          ("MediaPlaybackStatus=%p, " msg, this, ##__VA_ARGS__))
+
+void MediaPlaybackStatus::UpdateMediaPlaybackState(uint64_t aContextId,
+                                                   MediaPlaybackState aState) {
+  LOG("Update playback state '%s' for context %" PRIu64,
+      ToMediaPlaybackStateStr(aState), aContextId);
+  MOZ_ASSERT(NS_IsMainThread());
+
+  ContextMediaInfo& info = GetNotNullContextInfo(aContextId);
+  if (aState == MediaPlaybackState::eStarted) {
+    info.IncreaseControlledMediaNum();
+  } else if (aState == MediaPlaybackState::eStopped) {
+    info.DecreaseControlledMediaNum();
+  } else if (aState == MediaPlaybackState::ePlayed) {
+    info.IncreasePlayingMediaNum();
+  } else {
+    MOZ_ASSERT(aState == MediaPlaybackState::ePaused);
+    info.DecreasePlayingMediaNum();
+  }
+
+  // The context still has controlled media, we should keep its alive.
+  if (info.IsAnyMediaBeingControlled()) {
+    return;
+  }
+  MOZ_ASSERT(!info.IsPlaying());
+  MOZ_ASSERT(!info.IsAudible());
+  // DO NOT access `info` after this line.
+  DestroyContextInfo(aContextId);
+}
+
+void MediaPlaybackStatus::DestroyContextInfo(uint64_t aContextId) {
+  MOZ_ASSERT(NS_IsMainThread());
+  LOG("Remove context %" PRIu64, aContextId);
+  mContextInfoMap.Remove(aContextId);
+  // If the removed context is owning the audio focus, we would find another
+  // context to take the audio focus if it's possible.
+  if (IsContextOwningAudioFocus(aContextId)) {
+    ChooseNewContextToOwnAudioFocus();
+  }
+}
+
+void MediaPlaybackStatus::UpdateMediaAudibleState(uint64_t aContextId,
+                                                  MediaAudibleState aState) {
+  LOG("Update audible state '%s' for context %" PRIu64,
+      ToMediaAudibleStateStr(aState), aContextId);
+  MOZ_ASSERT(NS_IsMainThread());
+  ContextMediaInfo& info = GetNotNullContextInfo(aContextId);
+  if (aState == MediaAudibleState::eAudible) {
+    info.IncreaseAudibleMediaNum();
+  } else {
+    MOZ_ASSERT(aState == MediaAudibleState::eInaudible);
+    info.DecreaseAudibleMediaNum();
+  }
+  if (ShouldRequestAudioFocusForInfo(info)) {
+    SetOwningAudioFocusContextId(Some(aContextId));
+  } else if (ShouldAbandonAudioFocusForInfo(info)) {
+    ChooseNewContextToOwnAudioFocus();
+  }
+}
+
+bool MediaPlaybackStatus::IsPlaying() const {
+  MOZ_ASSERT(NS_IsMainThread());
+  return std::any_of(mContextInfoMap.Values().cbegin(),
+                     mContextInfoMap.Values().cend(),
+                     [](const auto& info) { return info->IsPlaying(); });
+}
+
+bool MediaPlaybackStatus::IsAudible() const {
+  MOZ_ASSERT(NS_IsMainThread());
+  return std::any_of(mContextInfoMap.Values().cbegin(),
+                     mContextInfoMap.Values().cend(),
+                     [](const auto& info) { return info->IsAudible(); });
+}
+
+bool MediaPlaybackStatus::IsAnyMediaBeingControlled() const {
+  MOZ_ASSERT(NS_IsMainThread());
+  return std::any_of(
+      mContextInfoMap.Values().cbegin(), mContextInfoMap.Values().cend(),
+      [](const auto& info) { return info->IsAnyMediaBeingControlled(); });
+}
+
+MediaPlaybackStatus::ContextMediaInfo&
+MediaPlaybackStatus::GetNotNullContextInfo(uint64_t aContextId) {
+  MOZ_ASSERT(NS_IsMainThread());
+  return *mContextInfoMap.GetOrInsertNew(aContextId, aContextId);
+}
+
+Maybe<uint64_t> MediaPlaybackStatus::GetAudioFocusOwnerContextId() const {
+  return mOwningAudioFocusContextId;
+}
+
+void MediaPlaybackStatus::ChooseNewContextToOwnAudioFocus() {
+  for (const auto& info : mContextInfoMap.Values()) {
+    if (info->IsAudible()) {
+      SetOwningAudioFocusContextId(Some(info->Id()));
+      return;
+    }
+  }
+  // No context is audible, so no one should the own audio focus.
+  SetOwningAudioFocusContextId(Nothing());
+}
+
+void MediaPlaybackStatus::SetOwningAudioFocusContextId(
+    Maybe<uint64_t>&& aContextId) {
+  if (mOwningAudioFocusContextId == aContextId) {
+    return;
+  }
+  mOwningAudioFocusContextId = aContextId;
+}
+
+bool MediaPlaybackStatus::ShouldRequestAudioFocusForInfo(
+    const ContextMediaInfo& aInfo) const {
+  return aInfo.IsAudible() && !IsContextOwningAudioFocus(aInfo.Id());
+}
+
+bool MediaPlaybackStatus::ShouldAbandonAudioFocusForInfo(
+    const ContextMediaInfo& aInfo) const {
+  // The owner becomes inaudible and there is other context still playing, so we
+  // should switch the audio focus to the audible context.
+  return !aInfo.IsAudible() && IsContextOwningAudioFocus(aInfo.Id()) &&
+         IsAudible();
+}
+
+bool MediaPlaybackStatus::IsContextOwningAudioFocus(uint64_t aContextId) const {
+  return mOwningAudioFocusContextId ? *mOwningAudioFocusContextId == aContextId
+                                    : false;
+}
+
+}  // namespace mozilla::dom
diff --git a/dom/media/mediacontrol/MediaPlaybackStatus.h b/dom/media/mediacontrol/MediaPlaybackStatus.h
new file mode 100644
index 0000000000..bf0a5cc611
--- /dev/null
+++ b/dom/media/mediacontrol/MediaPlaybackStatus.h
@@ -0,0 +1,139 @@
+/* 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 DOM_MEDIA_MEDIACONTROL_MEDIAPLAYBACKSTATUS_H_
+#define DOM_MEDIA_MEDIACONTROL_MEDIAPLAYBACKSTATUS_H_
+
+#include "mozilla/Maybe.h"
+#include "mozilla/RefPtr.h"
+#include "nsISupportsImpl.h"
+#include "nsTArray.h"
+#include "nsTHashMap.h"
+
+namespace mozilla::dom {
+
+/**
+ * This enum is used to update controlled media state to the media controller in
+ * the chrome process.
+ * `eStarted`: media has successfully registered to the content media controller
+ * `ePlayed` : media has started playing
+ * `ePaused` : media has paused playing, but still can be resumed by content
+ *             media controller
+ * `eStopped`: media has unregistered from the content media controller, we can
+ *             not control it anymore
+ */
+enum class MediaPlaybackState : uint32_t {
+  eStarted,
+  ePlayed,
+  ePaused,
+  eStopped,
+};
+
+/**
+ * This enum is used to update controlled media audible audible state to the
+ * media controller in the chrome process.
+ */
+enum class MediaAudibleState : bool {
+  eInaudible = false,
+  eAudible = true,
+};
+
+/**
+ * MediaPlaybackStatus is an internal module for the media controller, it
+ * represents a tab's media related status, such like "does the tab contain any
+ * controlled media? is the tab playing? is the tab audible?".
+ *
+ * The reason we need this class is that we would like to encapsulate the
+ * details of determining the tab's media status. A tab can contains multiple
+ * browsing contexts, and each browsing context can have different media status.
+ * The final media status would be decided by checking all those context status.
+ *
+ * Use `UpdateMediaXXXState()` to update controlled media status, and use
+ * `IsXXX()` methods to acquire the playback status of the tab.
+ *
+ * As we know each context's audible state, we can decide which context should
+ * owns the audio focus when multiple contexts are all playing audible media at
+ * the same time. In that cases, the latest context that plays media would own
+ * the audio focus. When the context owning the audio focus is destroyed, we
+ * would see if there is another other context still playing audible media, and
+ * switch the audio focus to another context.
+ */
+class MediaPlaybackStatus final {
+ public:
+  void UpdateMediaPlaybackState(uint64_t aContextId, MediaPlaybackState aState);
+  void UpdateMediaAudibleState(uint64_t aContextId, MediaAudibleState aState);
+
+  bool IsPlaying() const;
+  bool IsAudible() const;
+  bool IsAnyMediaBeingControlled() const;
+
+  Maybe<uint64_t> GetAudioFocusOwnerContextId() const;
+
+ private:
+  /**
+   * This internal class stores detailed media status of controlled media for
+   * a browsing context.
+   */
+  class ContextMediaInfo final {
+   public:
+    explicit ContextMediaInfo(uint64_t aContextId) : mContextId(aContextId) {}
+    ~ContextMediaInfo() = default;
+
+    void IncreaseControlledMediaNum() {
+      MOZ_DIAGNOSTIC_ASSERT(mControlledMediaNum < UINT_MAX);
+      mControlledMediaNum++;
+    }
+    void DecreaseControlledMediaNum() {
+      MOZ_DIAGNOSTIC_ASSERT(mControlledMediaNum > 0);
+      mControlledMediaNum--;
+    }
+    void IncreasePlayingMediaNum() {
+      MOZ_DIAGNOSTIC_ASSERT(mPlayingMediaNum < mControlledMediaNum);
+      mPlayingMediaNum++;
+    }
+    void DecreasePlayingMediaNum() {
+      MOZ_DIAGNOSTIC_ASSERT(mPlayingMediaNum > 0);
+      mPlayingMediaNum--;
+    }
+    void IncreaseAudibleMediaNum() {
+      MOZ_DIAGNOSTIC_ASSERT(mAudibleMediaNum < mPlayingMediaNum);
+      mAudibleMediaNum++;
+    }
+    void DecreaseAudibleMediaNum() {
+      MOZ_DIAGNOSTIC_ASSERT(mAudibleMediaNum > 0);
+      mAudibleMediaNum--;
+    }
+    bool IsPlaying() const { return mPlayingMediaNum > 0; }
+    bool IsAudible() const { return mAudibleMediaNum > 0; }
+    bool IsAnyMediaBeingControlled() const { return mControlledMediaNum > 0; }
+    uint64_t Id() const { return mContextId; }
+
+   private:
+    /**
+     * The possible value for those three numbers should follow this rule,
+     * mControlledMediaNum >= mPlayingMediaNum >= mAudibleMediaNum
+     */
+    uint32_t mControlledMediaNum = 0;
+    uint32_t mAudibleMediaNum = 0;
+    uint32_t mPlayingMediaNum = 0;
+    uint64_t mContextId = 0;
+  };
+
+  ContextMediaInfo& GetNotNullContextInfo(uint64_t aContextId);
+  void DestroyContextInfo(uint64_t aContextId);
+
+  void ChooseNewContextToOwnAudioFocus();
+  void SetOwningAudioFocusContextId(Maybe<uint64_t>&& aContextId);
+  bool IsContextOwningAudioFocus(uint64_t aContextId) const;
+  bool ShouldRequestAudioFocusForInfo(const ContextMediaInfo& aInfo) const;
+  bool ShouldAbandonAudioFocusForInfo(const ContextMediaInfo& aInfo) const;
+
+  // This contains all the media status of browsing contexts within a tab.
+  nsTHashMap<uint64_t, UniquePtr<ContextMediaInfo>> mContextInfoMap;
+  Maybe<uint64_t> mOwningAudioFocusContextId;
+};
+
+}  // namespace mozilla::dom
+
+#endif  //  DOM_MEDIA_MEDIACONTROL_MEDIAPLAYBACKSTATUS_H_
diff --git a/dom/media/mediacontrol/MediaStatusManager.cpp b/dom/media/mediacontrol/MediaStatusManager.cpp
new file mode 100644
index 0000000000..4365e6b531
--- /dev/null
+++ b/dom/media/mediacontrol/MediaStatusManager.cpp
@@ -0,0 +1,482 @@
+/* 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/. */
+
+#include "MediaStatusManager.h"
+
+#include "MediaControlService.h"
+#include "mozilla/dom/CanonicalBrowsingContext.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/MediaControlUtils.h"
+#include "mozilla/dom/WindowGlobalParent.h"
+#include "mozilla/StaticPrefs_media.h"
+#include "nsContentUtils.h"
+#include "nsIChromeRegistry.h"
+#include "nsIObserverService.h"
+#include "nsIXULAppInfo.h"
+#include "nsNetUtil.h"
+
+#ifdef MOZ_PLACES
+#  include "nsIFaviconService.h"
+#endif  // MOZ_PLACES
+
+extern mozilla::LazyLogModule gMediaControlLog;
+
+// avoid redefined macro in unified build
+#undef LOG
+#define LOG(msg, ...)                        \
+  MOZ_LOG(gMediaControlLog, LogLevel::Debug, \
+          ("MediaStatusManager=%p, " msg, this, ##__VA_ARGS__))
+
+namespace mozilla::dom {
+
+static bool IsMetadataEmpty(const Maybe<MediaMetadataBase>& aMetadata) {
+  // Media session's metadata is null.
+  if (!aMetadata) {
+    return true;
+  }
+
+  // All attirbutes in metadata are empty.
+  // https://w3c.github.io/mediasession/#empty-metadata
+  const MediaMetadataBase& metadata = *aMetadata;
+  return metadata.mTitle.IsEmpty() && metadata.mArtist.IsEmpty() &&
+         metadata.mAlbum.IsEmpty() && metadata.mArtwork.IsEmpty();
+}
+
+MediaStatusManager::MediaStatusManager(uint64_t aBrowsingContextId)
+    : mTopLevelBrowsingContextId(aBrowsingContextId) {
+  MOZ_DIAGNOSTIC_ASSERT(XRE_IsParentProcess(),
+                        "MediaStatusManager only runs on Chrome process!");
+}
+
+void MediaStatusManager::NotifyMediaAudibleChanged(uint64_t aBrowsingContextId,
+                                                   MediaAudibleState aState) {
+  Maybe<uint64_t> oldAudioFocusOwnerId =
+      mPlaybackStatusDelegate.GetAudioFocusOwnerContextId();
+  mPlaybackStatusDelegate.UpdateMediaAudibleState(aBrowsingContextId, aState);
+  Maybe<uint64_t> newAudioFocusOwnerId =
+      mPlaybackStatusDelegate.GetAudioFocusOwnerContextId();
+  if (oldAudioFocusOwnerId != newAudioFocusOwnerId) {
+    HandleAudioFocusOwnerChanged(newAudioFocusOwnerId);
+  }
+}
+
+void MediaStatusManager::NotifySessionCreated(uint64_t aBrowsingContextId) {
+  const bool created = mMediaSessionInfoMap.WithEntryHandle(
+      aBrowsingContextId, [&](auto&& entry) {
+        if (entry) return false;
+
+        LOG("Session %" PRIu64 " has been created", aBrowsingContextId);
+        entry.Insert(MediaSessionInfo::EmptyInfo());
+        return true;
+      });
+
+  if (created && IsSessionOwningAudioFocus(aBrowsingContextId)) {
+    // This can't be done from within the WithEntryHandle functor, since it
+    // accesses mMediaSessionInfoMap.
+    SetActiveMediaSessionContextId(aBrowsingContextId);
+  }
+}
+
+void MediaStatusManager::NotifySessionDestroyed(uint64_t aBrowsingContextId) {
+  if (mMediaSessionInfoMap.Remove(aBrowsingContextId)) {
+    LOG("Session %" PRIu64 " has been destroyed", aBrowsingContextId);
+
+    if (mActiveMediaSessionContextId &&
+        *mActiveMediaSessionContextId == aBrowsingContextId) {
+      ClearActiveMediaSessionContextIdIfNeeded();
+    }
+  }
+}
+
+void MediaStatusManager::UpdateMetadata(
+    uint64_t aBrowsingContextId, const Maybe<MediaMetadataBase>& aMetadata) {
+  auto info = mMediaSessionInfoMap.Lookup(aBrowsingContextId);
+  if (!info) {
+    return;
+  }
+  if (IsMetadataEmpty(aMetadata)) {
+    LOG("Reset metadata for session %" PRIu64, aBrowsingContextId);
+    info->mMetadata.reset();
+  } else {
+    LOG("Update metadata for session %" PRIu64 " title=%s artist=%s album=%s",
+        aBrowsingContextId, NS_ConvertUTF16toUTF8((*aMetadata).mTitle).get(),
+        NS_ConvertUTF16toUTF8(aMetadata->mArtist).get(),
+        NS_ConvertUTF16toUTF8(aMetadata->mAlbum).get());
+    info->mMetadata = aMetadata;
+  }
+  // Only notify the event if the changed metadata belongs to the active media
+  // session.
+  if (mActiveMediaSessionContextId &&
+      *mActiveMediaSessionContextId == aBrowsingContextId) {
+    LOG("Notify metadata change for active session %" PRIu64,
+        aBrowsingContextId);
+    mMetadataChangedEvent.Notify(GetCurrentMediaMetadata());
+  }
+  if (StaticPrefs::media_mediacontrol_testingevents_enabled()) {
+    if (nsCOMPtr<nsIObserverService> obs = services::GetObserverService()) {
+      obs->NotifyObservers(nullptr, "media-session-controller-metadata-changed",
+                           nullptr);
+    }
+  }
+}
+
+void MediaStatusManager::HandleAudioFocusOwnerChanged(
+    Maybe<uint64_t>& aBrowsingContextId) {
+  // No one is holding the audio focus.
+  if (!aBrowsingContextId) {
+    LOG("No one is owning audio focus");
+    return ClearActiveMediaSessionContextIdIfNeeded();
+  }
+
+  // This owner of audio focus doesn't have media session, so we should deactive
+  // the active session because the active session must own the audio focus.
+  if (!mMediaSessionInfoMap.Contains(*aBrowsingContextId)) {
+    LOG("The owner of audio focus doesn't have media session");
+    return ClearActiveMediaSessionContextIdIfNeeded();
+  }
+
+  // This owner has media session so it should become an active session context.
+  SetActiveMediaSessionContextId(*aBrowsingContextId);
+}
+
+void MediaStatusManager::SetActiveMediaSessionContextId(
+    uint64_t aBrowsingContextId) {
+  if (mActiveMediaSessionContextId &&
+      *mActiveMediaSessionContextId == aBrowsingContextId) {
+    LOG("Active session context %" PRIu64 " keeps unchanged",
+        *mActiveMediaSessionContextId);
+    return;
+  }
+  mActiveMediaSessionContextId = Some(aBrowsingContextId);
+  StoreMediaSessionContextIdOnWindowContext();
+  LOG("context %" PRIu64 " becomes active session context",
+      *mActiveMediaSessionContextId);
+  mMetadataChangedEvent.Notify(GetCurrentMediaMetadata());
+  mSupportedActionsChangedEvent.Notify(GetSupportedActions());
+  if (StaticPrefs::media_mediacontrol_testingevents_enabled()) {
+    if (nsCOMPtr<nsIObserverService> obs = services::GetObserverService()) {
+      obs->NotifyObservers(nullptr, "active-media-session-changed", nullptr);
+    }
+  }
+}
+
+void MediaStatusManager::ClearActiveMediaSessionContextIdIfNeeded() {
+  if (!mActiveMediaSessionContextId) {
+    return;
+  }
+  LOG("Clear active session context");
+  mActiveMediaSessionContextId.reset();
+  StoreMediaSessionContextIdOnWindowContext();
+  mMetadataChangedEvent.Notify(GetCurrentMediaMetadata());
+  mSupportedActionsChangedEvent.Notify(GetSupportedActions());
+  if (StaticPrefs::media_mediacontrol_testingevents_enabled()) {
+    if (nsCOMPtr<nsIObserverService> obs = services::GetObserverService()) {
+      obs->NotifyObservers(nullptr, "active-media-session-changed", nullptr);
+    }
+  }
+}
+
+void MediaStatusManager::StoreMediaSessionContextIdOnWindowContext() {
+  RefPtr<CanonicalBrowsingContext> bc =
+      CanonicalBrowsingContext::Get(mTopLevelBrowsingContextId);
+  if (bc && bc->GetTopWindowContext()) {
+    Unused << bc->GetTopWindowContext()->SetActiveMediaSessionContextId(
+        mActiveMediaSessionContextId);
+  }
+}
+
+bool MediaStatusManager::IsSessionOwningAudioFocus(
+    uint64_t aBrowsingContextId) const {
+  Maybe<uint64_t> audioFocusContextId =
+      mPlaybackStatusDelegate.GetAudioFocusOwnerContextId();
+  return audioFocusContextId ? *audioFocusContextId == aBrowsingContextId
+                             : false;
+}
+
+MediaMetadataBase MediaStatusManager::CreateDefaultMetadata() const {
+  MediaMetadataBase metadata;
+  metadata.mTitle = GetDefaultTitle();
+  metadata.mArtwork.AppendElement()->mSrc = GetDefaultFaviconURL();
+
+  LOG("Default media metadata, title=%s, album src=%s",
+      NS_ConvertUTF16toUTF8(metadata.mTitle).get(),
+      NS_ConvertUTF16toUTF8(metadata.mArtwork[0].mSrc).get());
+  return metadata;
+}
+
+nsString MediaStatusManager::GetDefaultTitle() const {
+  RefPtr<MediaControlService> service = MediaControlService::GetService();
+  nsString defaultTitle = service->GetFallbackTitle();
+
+  RefPtr<CanonicalBrowsingContext> bc =
+      CanonicalBrowsingContext::Get(mTopLevelBrowsingContextId);
+  if (!bc) {
+    return defaultTitle;
+  }
+
+  RefPtr<WindowGlobalParent> globalParent = bc->GetCurrentWindowGlobal();
+  if (!globalParent) {
+    return defaultTitle;
+  }
+
+  // The media metadata would be shown on the virtual controller interface. For
+  // example, on Android, the interface would be shown on both notification bar
+  // and lockscreen. Therefore, what information we provide via metadata is
+  // quite important, because if we're in private browsing, we don't want to
+  // expose details about what website the user is browsing on the lockscreen.
+  // Therefore, using the default title when in the private browsing or the
+  // document title is empty. Otherwise, use the document title.
+  nsString documentTitle;
+  if (!IsInPrivateBrowsing()) {
+    globalParent->GetDocumentTitle(documentTitle);
+  }
+  return documentTitle.IsEmpty() ? defaultTitle : documentTitle;
+}
+
+nsString MediaStatusManager::GetDefaultFaviconURL() const {
+#ifdef MOZ_PLACES
+  nsCOMPtr<nsIURI> faviconURI;
+  nsresult rv = NS_NewURI(getter_AddRefs(faviconURI),
+                          nsLiteralCString(FAVICON_DEFAULT_URL));
+  NS_ENSURE_SUCCESS(rv, u""_ns);
+
+  // Convert URI from `chrome://XXX` to `file://XXX` because we would like to
+  // let OS related frameworks, such as SMTC and MPRIS, handle this URL in order
+  // to show the icon on virtual controller interface.
+  nsCOMPtr<nsIChromeRegistry> regService = services::GetChromeRegistry();
+  if (!regService) {
+    return u""_ns;
+  }
+  nsCOMPtr<nsIURI> processedURI;
+  regService->ConvertChromeURL(faviconURI, getter_AddRefs(processedURI));
+
+  nsAutoCString spec;
+  if (NS_FAILED(processedURI->GetSpec(spec))) {
+    return u""_ns;
+  }
+  return NS_ConvertUTF8toUTF16(spec);
+#else
+  return u""_ns;
+#endif
+}
+
+void MediaStatusManager::SetDeclaredPlaybackState(
+    uint64_t aBrowsingContextId, MediaSessionPlaybackState aState) {
+  auto info = mMediaSessionInfoMap.Lookup(aBrowsingContextId);
+  if (!info) {
+    return;
+  }
+  LOG("SetDeclaredPlaybackState from %s to %s",
+      ToMediaSessionPlaybackStateStr(info->mDeclaredPlaybackState),
+      ToMediaSessionPlaybackStateStr(aState));
+  info->mDeclaredPlaybackState = aState;
+  UpdateActualPlaybackState();
+}
+
+MediaSessionPlaybackState MediaStatusManager::GetCurrentDeclaredPlaybackState()
+    const {
+  if (!mActiveMediaSessionContextId) {
+    return MediaSessionPlaybackState::None;
+  }
+  return mMediaSessionInfoMap.Get(*mActiveMediaSessionContextId)
+      .mDeclaredPlaybackState;
+}
+
+void MediaStatusManager::NotifyMediaPlaybackChanged(uint64_t aBrowsingContextId,
+                                                    MediaPlaybackState aState) {
+  LOG("UpdateMediaPlaybackState %s for context %" PRIu64,
+      ToMediaPlaybackStateStr(aState), aBrowsingContextId);
+  const bool oldPlaying = mPlaybackStatusDelegate.IsPlaying();
+  mPlaybackStatusDelegate.UpdateMediaPlaybackState(aBrowsingContextId, aState);
+
+  // Playback state doesn't change, we don't need to update the guessed playback
+  // state. This is used to prevent the state from changing from `none` to
+  // `paused` when receiving `MediaPlaybackState::eStarted`.
+  if (mPlaybackStatusDelegate.IsPlaying() == oldPlaying) {
+    return;
+  }
+  if (mPlaybackStatusDelegate.IsPlaying()) {
+    SetGuessedPlayState(MediaSessionPlaybackState::Playing);
+  } else {
+    SetGuessedPlayState(MediaSessionPlaybackState::Paused);
+  }
+}
+
+void MediaStatusManager::SetGuessedPlayState(MediaSessionPlaybackState aState) {
+  if (aState == mGuessedPlaybackState) {
+    return;
+  }
+  LOG("SetGuessedPlayState : '%s'", ToMediaSessionPlaybackStateStr(aState));
+  mGuessedPlaybackState = aState;
+  UpdateActualPlaybackState();
+}
+
+void MediaStatusManager::UpdateActualPlaybackState() {
+  // The way to compute the actual playback state is based on the spec.
+  // https://w3c.github.io/mediasession/#actual-playback-state
+  MediaSessionPlaybackState newState =
+      GetCurrentDeclaredPlaybackState() == MediaSessionPlaybackState::Playing
+          ? MediaSessionPlaybackState::Playing
+          : mGuessedPlaybackState;
+  if (mActualPlaybackState == newState) {
+    return;
+  }
+  mActualPlaybackState = newState;
+  LOG("UpdateActualPlaybackState : '%s'",
+      ToMediaSessionPlaybackStateStr(mActualPlaybackState));
+  mPlaybackStateChangedEvent.Notify(mActualPlaybackState);
+}
+
+void MediaStatusManager::EnableAction(uint64_t aBrowsingContextId,
+                                      MediaSessionAction aAction) {
+  auto info = mMediaSessionInfoMap.Lookup(aBrowsingContextId);
+  if (!info) {
+    return;
+  }
+  if (info->IsActionSupported(aAction)) {
+    LOG("Action '%s' has already been enabled for context %" PRIu64,
+        ToMediaSessionActionStr(aAction), aBrowsingContextId);
+    return;
+  }
+  LOG("Enable action %s for context %" PRIu64, ToMediaSessionActionStr(aAction),
+      aBrowsingContextId);
+  info->EnableAction(aAction);
+  NotifySupportedKeysChangedIfNeeded(aBrowsingContextId);
+}
+
+void MediaStatusManager::DisableAction(uint64_t aBrowsingContextId,
+                                       MediaSessionAction aAction) {
+  auto info = mMediaSessionInfoMap.Lookup(aBrowsingContextId);
+  if (!info) {
+    return;
+  }
+  if (!info->IsActionSupported(aAction)) {
+    LOG("Action '%s' hasn't been enabled yet for context %" PRIu64,
+        ToMediaSessionActionStr(aAction), aBrowsingContextId);
+    return;
+  }
+  LOG("Disable action %s for context %" PRIu64,
+      ToMediaSessionActionStr(aAction), aBrowsingContextId);
+  info->DisableAction(aAction);
+  NotifySupportedKeysChangedIfNeeded(aBrowsingContextId);
+}
+
+void MediaStatusManager::UpdatePositionState(uint64_t aBrowsingContextId,
+                                             const PositionState& aState) {
+  // The position state comes from non-active media session which we don't care.
+  if (!mActiveMediaSessionContextId ||
+      *mActiveMediaSessionContextId != aBrowsingContextId) {
+    return;
+  }
+  mPositionStateChangedEvent.Notify(aState);
+}
+
+void MediaStatusManager::NotifySupportedKeysChangedIfNeeded(
+    uint64_t aBrowsingContextId) {
+  // Only the active media session's supported actions would be shown in virtual
+  // control interface, so we only notify the event when supported actions
+  // change happens on the active media session.
+  if (!mActiveMediaSessionContextId ||
+      *mActiveMediaSessionContextId != aBrowsingContextId) {
+    return;
+  }
+  mSupportedActionsChangedEvent.Notify(GetSupportedActions());
+}
+
+CopyableTArray<MediaSessionAction> MediaStatusManager::GetSupportedActions()
+    const {
+  CopyableTArray<MediaSessionAction> supportedActions;
+  if (!mActiveMediaSessionContextId) {
+    return supportedActions;
+  }
+
+  MediaSessionInfo info =
+      mMediaSessionInfoMap.Get(*mActiveMediaSessionContextId);
+  const uint8_t actionNums = uint8_t(MediaSessionAction::EndGuard_);
+  for (uint8_t actionValue = 0; actionValue < actionNums; actionValue++) {
+    MediaSessionAction action = ConvertToMediaSessionAction(actionValue);
+    if (info.IsActionSupported(action)) {
+      supportedActions.AppendElement(action);
+    }
+  }
+  return supportedActions;
+}
+
+MediaMetadataBase MediaStatusManager::GetCurrentMediaMetadata() const {
+  // If we don't have active media session, active media session doesn't have
+  // media metadata, or we're in private browsing mode, then we should create a
+  // default metadata which is using website's title and favicon as title and
+  // artwork.
+  if (mActiveMediaSessionContextId && !IsInPrivateBrowsing()) {
+    MediaSessionInfo info =
+        mMediaSessionInfoMap.Get(*mActiveMediaSessionContextId);
+    if (!info.mMetadata) {
+      return CreateDefaultMetadata();
+    }
+    MediaMetadataBase& metadata = *(info.mMetadata);
+    FillMissingTitleAndArtworkIfNeeded(metadata);
+    return metadata;
+  }
+  return CreateDefaultMetadata();
+}
+
+void MediaStatusManager::FillMissingTitleAndArtworkIfNeeded(
+    MediaMetadataBase& aMetadata) const {
+  // If the metadata doesn't set its title and artwork properly, we would like
+  // to use default title and favicon instead in order to prevent showing
+  // nothing on the virtual control interface.
+  if (aMetadata.mTitle.IsEmpty()) {
+    aMetadata.mTitle = GetDefaultTitle();
+  }
+  if (aMetadata.mArtwork.IsEmpty()) {
+    aMetadata.mArtwork.AppendElement()->mSrc = GetDefaultFaviconURL();
+  }
+}
+
+bool MediaStatusManager::IsInPrivateBrowsing() const {
+  RefPtr<CanonicalBrowsingContext> bc =
+      CanonicalBrowsingContext::Get(mTopLevelBrowsingContextId);
+  if (!bc) {
+    return false;
+  }
+  RefPtr<Element> element = bc->GetEmbedderElement();
+  if (!element) {
+    return false;
+  }
+  return nsContentUtils::IsInPrivateBrowsing(element->OwnerDoc());
+}
+
+MediaSessionPlaybackState MediaStatusManager::PlaybackState() const {
+  return mActualPlaybackState;
+}
+
+bool MediaStatusManager::IsMediaAudible() const {
+  return mPlaybackStatusDelegate.IsAudible();
+}
+
+bool MediaStatusManager::IsMediaPlaying() const {
+  return mActualPlaybackState == MediaSessionPlaybackState::Playing;
+}
+
+bool MediaStatusManager::IsAnyMediaBeingControlled() const {
+  return mPlaybackStatusDelegate.IsAnyMediaBeingControlled();
+}
+
+void MediaStatusManager::NotifyPageTitleChanged() {
+  // If active media session has set non-empty metadata, then we would use that
+  // instead of using default metadata.
+  if (mActiveMediaSessionContextId &&
+      mMediaSessionInfoMap.Lookup(*mActiveMediaSessionContextId)->mMetadata) {
+    return;
+  }
+  // In private browsing mode, we won't show page title on default metadata so
+  // we don't need to update that.
+  if (IsInPrivateBrowsing()) {
+    return;
+  }
+  LOG("page title changed, update default metadata");
+  mMetadataChangedEvent.Notify(GetCurrentMediaMetadata());
+}
+
+}  // namespace mozilla::dom
diff --git a/dom/media/mediacontrol/MediaStatusManager.h b/dom/media/mediacontrol/MediaStatusManager.h
new file mode 100644
index 0000000000..24247d119d
--- /dev/null
+++ b/dom/media/mediacontrol/MediaStatusManager.h
@@ -0,0 +1,276 @@
+/* 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 DOM_MEDIA_MEDIACONTROL_MEDIASTATUSMANAGER_H_
+#define DOM_MEDIA_MEDIACONTROL_MEDIASTATUSMANAGER_H_
+
+#include "MediaControlKeySource.h"
+#include "MediaEventSource.h"
+#include "MediaPlaybackStatus.h"
+#include "mozilla/dom/MediaMetadata.h"
+#include "mozilla/dom/MediaSessionBinding.h"
+#include "mozilla/Maybe.h"
+#include "nsTHashMap.h"
+#include "nsISupportsImpl.h"
+
+namespace mozilla::dom {
+
+class MediaSessionInfo {
+ public:
+  MediaSessionInfo() = default;
+
+  explicit MediaSessionInfo(MediaMetadataBase& aMetadata) {
+    mMetadata.emplace(aMetadata);
+  }
+
+  MediaSessionInfo(MediaMetadataBase& aMetadata,
+                   MediaSessionPlaybackState& aState) {
+    mMetadata.emplace(aMetadata);
+    mDeclaredPlaybackState = aState;
+  }
+
+  static MediaSessionInfo EmptyInfo() { return MediaSessionInfo(); }
+
+  static uint32_t GetActionBitMask(MediaSessionAction aAction) {
+    return 1 << static_cast<uint8_t>(aAction);
+  }
+
+  void EnableAction(MediaSessionAction aAction) {
+    mSupportedActions |= GetActionBitMask(aAction);
+  }
+
+  void DisableAction(MediaSessionAction aAction) {
+    mSupportedActions &= ~GetActionBitMask(aAction);
+  }
+
+  bool IsActionSupported(MediaSessionAction aAction) const {
+    return mSupportedActions & GetActionBitMask(aAction);
+  }
+
+  // These attributes are all propagated from the media session in the content
+  // process.
+  Maybe<MediaMetadataBase> mMetadata;
+  MediaSessionPlaybackState mDeclaredPlaybackState =
+      MediaSessionPlaybackState::None;
+  // Use bitwise to store the supported actions.
+  uint32_t mSupportedActions = 0;
+};
+
+/**
+ * IMediaInfoUpdater is an interface which provides methods to update the media
+ * related information that happens in the content process.
+ */
+class IMediaInfoUpdater {
+  NS_INLINE_DECL_PURE_VIRTUAL_REFCOUNTING
+
+  // Use this method to update controlled media's playback state and the
+  // browsing context where controlled media exists. When notifying the state
+  // change, we MUST follow the following rules.
+  // (1) `eStart` MUST be the first state and `eStop` MUST be the last state
+  // (2) Do not notify same state again
+  // (3) `ePaused` can only be notified after notifying `ePlayed`.
+  virtual void NotifyMediaPlaybackChanged(uint64_t aBrowsingContextId,
+                                          MediaPlaybackState aState) = 0;
+
+  // Use this method to update the audible state of controlled media, and MUST
+  // follow the following rules in which `audible` and `inaudible` should be a
+  // pair. `inaudible` should always be notified after `audible`. When audible
+  // media paused, `inaudible` should be notified
+  // Eg. (O) `audible` -> `inaudible` -> `audible` -> `inaudible`
+  //     (X) `inaudible` -> `audible`    [notify `inaudible` before `audible`]
+  //     (X) `audible` -> `audible`      [notify `audible` twice]
+  //     (X) `audible` -> (media pauses) [forgot to notify `inaudible`]
+  virtual void NotifyMediaAudibleChanged(uint64_t aBrowsingContextId,
+                                         MediaAudibleState aState) = 0;
+
+  // Use this method to update media session's declared playback state for the
+  // specific media session.
+  virtual void SetDeclaredPlaybackState(uint64_t aBrowsingContextId,
+                                        MediaSessionPlaybackState aState) = 0;
+
+  // Use these methods to update controller's media session list. We'd use it
+  // when media session is created/destroyed in the content process.
+  virtual void NotifySessionCreated(uint64_t aBrowsingContextId) = 0;
+  virtual void NotifySessionDestroyed(uint64_t aBrowsingContextId) = 0;
+
+  // Use this method to update the metadata for the specific media session.
+  virtual void UpdateMetadata(uint64_t aBrowsingContextId,
+                              const Maybe<MediaMetadataBase>& aMetadata) = 0;
+
+  // Use this method to update the picture in picture mode state of controlled
+  // media, and it's safe to notify same state again.
+  virtual void SetIsInPictureInPictureMode(uint64_t aBrowsingContextId,
+                                           bool aIsInPictureInPictureMode) = 0;
+
+  // Use these methods to update the supported media session action for the
+  // specific media session. For a media session from a given browsing context,
+  // do not re-enable the same action, or disable the action without enabling it
+  // before.
+  virtual void EnableAction(uint64_t aBrowsingContextId,
+                            MediaSessionAction aAction) = 0;
+  virtual void DisableAction(uint64_t aBrowsingContextId,
+                             MediaSessionAction aAction) = 0;
+
+  // Use this method when media enters or leaves the fullscreen.
+  virtual void NotifyMediaFullScreenState(uint64_t aBrowsingContextId,
+                                          bool aIsInFullScreen) = 0;
+
+  // Use this method when media session update its position state.
+  virtual void UpdatePositionState(uint64_t aBrowsingContextId,
+                                   const PositionState& aState) = 0;
+};
+
+/**
+ * MediaStatusManager would decide the media related status which can represents
+ * the whole tab. The status includes the playback status, tab's metadata and
+ * the active media session ID if it exists.
+ *
+ * We would use `IMediaInfoUpdater` methods to update the media playback related
+ * information and then use `MediaPlaybackStatus` to determine the final
+ * playback state.
+ *
+ * The metadata would be the one from the active media session, or the default
+ * one. This class would determine which media session is an active media
+ * session [1] whithin a tab. It tracks all alive media sessions within a tab
+ * and store their metadata which could be used to show on the virtual media
+ * control interface. In addition, we can use it to get the current media
+ * metadata even if there is no media session existing. However, the meaning of
+ * active media session here is not equal to the definition from the spec [1].
+ * We just choose the session which is the active one inside the tab, the global
+ * active media session among different tabs would be the one inside the main
+ * controller which is determined by MediaControlService.
+ *
+ * [1] https://w3c.github.io/mediasession/#active-media-session
+ */
+class MediaStatusManager : public IMediaInfoUpdater {
+ public:
+  explicit MediaStatusManager(uint64_t aBrowsingContextId);
+
+  // IMediaInfoUpdater's methods
+  void NotifyMediaPlaybackChanged(uint64_t aBrowsingContextId,
+                                  MediaPlaybackState aState) override;
+  void NotifyMediaAudibleChanged(uint64_t aBrowsingContextId,
+                                 MediaAudibleState aState) override;
+  void SetDeclaredPlaybackState(uint64_t aSessionContextId,
+                                MediaSessionPlaybackState aState) override;
+  void NotifySessionCreated(uint64_t aSessionContextId) override;
+  void NotifySessionDestroyed(uint64_t aSessionContextId) override;
+  void UpdateMetadata(uint64_t aSessionContextId,
+                      const Maybe<MediaMetadataBase>& aMetadata) override;
+  void EnableAction(uint64_t aBrowsingContextId,
+                    MediaSessionAction aAction) override;
+  void DisableAction(uint64_t aBrowsingContextId,
+                     MediaSessionAction aAction) override;
+  void UpdatePositionState(uint64_t aBrowsingContextId,
+                           const PositionState& aState) override;
+
+  // Return active media session's metadata if active media session exists and
+  // it has already set its metadata. Otherwise, return default media metadata
+  // which is based on website's title and favicon.
+  MediaMetadataBase GetCurrentMediaMetadata() const;
+
+  bool IsMediaAudible() const;
+  bool IsMediaPlaying() const;
+  bool IsAnyMediaBeingControlled() const;
+
+  // These events would be notified when the active media session's certain
+  // property changes.
+  MediaEventSource<MediaMetadataBase>& MetadataChangedEvent() {
+    return mMetadataChangedEvent;
+  }
+
+  MediaEventSource<PositionState>& PositionChangedEvent() {
+    return mPositionStateChangedEvent;
+  }
+
+  MediaEventSource<MediaSessionPlaybackState>& PlaybackChangedEvent() {
+    return mPlaybackStateChangedEvent;
+  }
+
+  // Return the actual playback state.
+  MediaSessionPlaybackState PlaybackState() const;
+
+  // When page title changes, we might need to update it on the default
+  // metadata as well.
+  void NotifyPageTitleChanged();
+
+ protected:
+  ~MediaStatusManager() = default;
+
+  // This event would be notified when the active media session changes its
+  // supported actions.
+  MediaEventSource<nsTArray<MediaSessionAction>>&
+  SupportedActionsChangedEvent() {
+    return mSupportedActionsChangedEvent;
+  }
+
+  uint64_t mTopLevelBrowsingContextId;
+
+  // Within a tab, the Id of the browsing context which has already created a
+  // media session and owns the audio focus within a tab.
+  Maybe<uint64_t> mActiveMediaSessionContextId;
+
+  void ClearActiveMediaSessionContextIdIfNeeded();
+
+ private:
+  nsString GetDefaultFaviconURL() const;
+  nsString GetDefaultTitle() const;
+  MediaMetadataBase CreateDefaultMetadata() const;
+  bool IsInPrivateBrowsing() const;
+  void FillMissingTitleAndArtworkIfNeeded(MediaMetadataBase& aMetadata) const;
+
+  bool IsSessionOwningAudioFocus(uint64_t aBrowsingContextId) const;
+  void SetActiveMediaSessionContextId(uint64_t aBrowsingContextId);
+  void HandleAudioFocusOwnerChanged(Maybe<uint64_t>& aBrowsingContextId);
+
+  void NotifySupportedKeysChangedIfNeeded(uint64_t aBrowsingContextId);
+
+  // Return a copyable array filled with the supported media session actions.
+  // Use copyable array so that we can use the result as a parameter for the
+  // media event.
+  CopyableTArray<MediaSessionAction> GetSupportedActions() const;
+
+  void StoreMediaSessionContextIdOnWindowContext();
+
+  // When the amount of playing media changes, we would use this function to
+  // update the guessed playback state.
+  void SetGuessedPlayState(MediaSessionPlaybackState aState);
+
+  // Whenever the declared playback state or the guessed playback state changes,
+  // we should recompute actual playback state to know if we need to update the
+  // virtual control interface.
+  void UpdateActualPlaybackState();
+
+  // Return the active media session's declared playback state. If the active
+  // media session doesn't exist, return  'None' instead.
+  MediaSessionPlaybackState GetCurrentDeclaredPlaybackState() const;
+
+  // This state can match to the `guessed playback state` in the spec [1], it
+  // indicates if we have any media element playing within the tab which this
+  // controller belongs to. But currently we only take media elements into
+  // account, which is different from the way the spec recommends. In addition,
+  // We don't support web audio and plugin and not consider audible state of
+  // media.
+  // [1] https://w3c.github.io/mediasession/#guessed-playback-state
+  MediaSessionPlaybackState mGuessedPlaybackState =
+      MediaSessionPlaybackState::None;
+
+  // This playback state would be the final playback which can be used to know
+  // if the controller is playing or not.
+  // https://w3c.github.io/mediasession/#actual-playback-state
+  MediaSessionPlaybackState mActualPlaybackState =
+      MediaSessionPlaybackState::None;
+
+  nsTHashMap<nsUint64HashKey, MediaSessionInfo> mMediaSessionInfoMap;
+  MediaEventProducer<MediaMetadataBase> mMetadataChangedEvent;
+  MediaEventProducer<nsTArray<MediaSessionAction>>
+      mSupportedActionsChangedEvent;
+  MediaEventProducer<PositionState> mPositionStateChangedEvent;
+  MediaEventProducer<MediaSessionPlaybackState> mPlaybackStateChangedEvent;
+  MediaPlaybackStatus mPlaybackStatusDelegate;
+};
+
+}  // namespace mozilla::dom
+
+#endif  // DOM_MEDIA_MEDIACONTROL_MEDIASTATUSMANAGER_H_
diff --git a/dom/media/mediacontrol/PositionStateEvent.h b/dom/media/mediacontrol/PositionStateEvent.h
new file mode 100644
index 0000000000..5d6a5ebb78
--- /dev/null
+++ b/dom/media/mediacontrol/PositionStateEvent.h
@@ -0,0 +1,60 @@
+/* -*- 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/. */
+
+/* THIS FILE IS AUTOGENERATED FROM PositionStateEvent.webidl BY Codegen.py - DO
+ * NOT EDIT */
+
+#ifndef mozilla_dom_PositionStateEvent_h
+#define mozilla_dom_PositionStateEvent_h
+
+#include "js/RootingAPI.h"
+#include "mozilla/AlreadyAddRefed.h"
+#include "mozilla/dom/Event.h"
+#include "nsISupports.h"
+#include "nsStringFwd.h"
+
+struct JSContext;
+namespace mozilla {
+namespace dom {
+struct PositionStateEventInit;
+
+class PositionStateEvent : public Event {
+ public:
+  NS_INLINE_DECL_REFCOUNTING_INHERITED(PositionStateEvent, Event)
+
+ protected:
+  virtual ~PositionStateEvent();
+  explicit PositionStateEvent(mozilla::dom::EventTarget* aOwner);
+
+  double mDuration;
+  double mPlaybackRate;
+  double mPosition;
+
+ public:
+  PositionStateEvent* AsPositionStateEvent() override;
+
+  JSObject* WrapObjectInternal(JSContext* aCx,
+                               JS::Handle<JSObject*> aGivenProto) override;
+
+  static already_AddRefed<PositionStateEvent> Constructor(
+      mozilla::dom::EventTarget* aOwner, const nsAString& aType,
+      const PositionStateEventInit& aEventInitDict);
+
+  static already_AddRefed<PositionStateEvent> Constructor(
+      const GlobalObject& aGlobal, const nsAString& aType,
+      const PositionStateEventInit& aEventInitDict);
+
+  double Duration() const;
+
+  double PlaybackRate() const;
+
+  double Position() const;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_PositionStateEvent_h
diff --git a/dom/media/mediacontrol/moz.build b/dom/media/mediacontrol/moz.build
new file mode 100644
index 0000000000..54b3c40a36
--- /dev/null
+++ b/dom/media/mediacontrol/moz.build
@@ -0,0 +1,43 @@
+# vim: set filetype=python:
+# 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/.
+
+EXPORTS.mozilla.dom += [
+    "AudioFocusManager.h",
+    "ContentMediaController.h",
+    "ContentPlaybackController.h",
+    "FetchImageHelper.h",
+    "MediaControlKeyManager.h",
+    "MediaControlKeySource.h",
+    "MediaController.h",
+    "MediaControlService.h",
+    "MediaControlUtils.h",
+    "MediaPlaybackStatus.h",
+    "MediaStatusManager.h",
+]
+
+EXPORTS.ipc += [
+    "MediaControlIPC.h",
+]
+
+UNIFIED_SOURCES += [
+    "AudioFocusManager.cpp",
+    "ContentMediaController.cpp",
+    "ContentPlaybackController.cpp",
+    "FetchImageHelper.cpp",
+    "MediaControlKeyManager.cpp",
+    "MediaControlKeySource.cpp",
+    "MediaController.cpp",
+    "MediaControlService.cpp",
+    "MediaControlUtils.cpp",
+    "MediaPlaybackStatus.cpp",
+    "MediaStatusManager.cpp",
+]
+
+include("/ipc/chromium/chromium-config.mozbuild")
+
+if CONFIG["ENABLE_TESTS"]:
+    DIRS += ["tests/gtest"]
+
+FINAL_LIBRARY = "xul"
diff --git a/dom/media/mediacontrol/tests/browser/browser.ini b/dom/media/mediacontrol/tests/browser/browser.ini
new file mode 100644
index 0000000000..d6338e598b
--- /dev/null
+++ b/dom/media/mediacontrol/tests/browser/browser.ini
@@ -0,0 +1,53 @@
+[DEFAULT]
+subsuite = media-bc
+tags = mediacontrol
+skip-if = os == "linux" # Bug 1673527
+support-files =
+  file_autoplay.html
+  file_audio_and_inaudible_media.html
+  file_empty_title.html
+  file_error_media.html
+  file_iframe_media.html
+  file_main_frame_with_multiple_child_session_frames.html
+  file_multiple_audible_media.html
+  file_muted_autoplay.html
+  file_no_src_media.html
+  file_non_autoplay.html
+  file_non_eligible_media.html
+  file_non_looping_media.html
+  head.js
+  ../../../test/bogus.ogv
+  ../../../test/gizmo.mp4
+  ../../../test/gizmo-noaudio.webm
+  ../../../test/gizmo-short.mp4
+  !/toolkit/components/pictureinpicture/tests/head.js
+  ../../../../../toolkit/content/tests/browser/silentAudioTrack.webm
+
+[browser_audio_focus_management.js]
+skip-if =
+  os == "win" && os_version == "6.1" # Skip on Azure - frequent failure
+[browser_control_page_with_audible_and_inaudible_media.js]
+[browser_default_action_handler.js]
+[browser_only_control_non_real_time_media.js]
+[browser_media_control_audio_focus_within_a_page.js]
+[browser_media_control_before_media_starts.js]
+[browser_media_control_captured_audio.js]
+[browser_media_control_metadata.js]
+[browser_media_control_keys_event.js]
+[browser_media_control_main_controller.js]
+[browser_media_control_non_eligible_media.js]
+skip-if =
+  verify && os == 'mac' # bug 1673509
+[browser_media_control_playback_state.js]
+[browser_media_control_position_state.js]
+[browser_media_control_seekto.js]
+[browser_media_control_supported_keys.js]
+[browser_media_control_stop_timer.js]
+[browser_nosrc_and_error_media.js]
+skip-if =
+  verify && os == 'mac' # bug 1673509
+[browser_seek_captured_audio.js]
+[browser_stop_control_after_media_reaches_to_end.js]
+[browser_suspend_inactive_tab.js]
+[browser_remove_controllable_media_for_active_controller.js]
+[browser_resume_latest_paused_media.js]
diff --git a/dom/media/mediacontrol/tests/browser/browser_audio_focus_management.js b/dom/media/mediacontrol/tests/browser/browser_audio_focus_management.js
new file mode 100644
index 0000000000..980281243d
--- /dev/null
+++ b/dom/media/mediacontrol/tests/browser/browser_audio_focus_management.js
@@ -0,0 +1,179 @@
+const PAGE_AUDIBLE =
+  "https://example.com/browser/dom/media/mediacontrol/tests/browser/file_autoplay.html";
+const PAGE_INAUDIBLE =
+  "https://example.com/browser/dom/media/mediacontrol/tests/browser/file_muted_autoplay.html";
+
+const testVideoId = "autoplay";
+
+/**
+ * These tests are used to ensure that the audio focus management works correctly
+ * amongs different tabs no matter the pref is on or off. If the pref is on,
+ * there is only one tab which is allowed to play audio at a time, the last tab
+ * starting audio will immediately stop other tabs which own audio focus. But
+ * notice that playing inaudible media won't gain audio focus. If the pref is
+ * off, all audible tabs can own audio focus at the same time without
+ * interfering each others.
+ */
+add_task(async function testDisableAudioFocusManagement() {
+  await switchAudioFocusManagerment(false);
+
+  info(`open audible autoplay media in tab1`);
+  const tab1 = await createLoadedTabWrapper(PAGE_AUDIBLE, { needCheck: false });
+  await checkOrWaitUntilMediaStartedPlaying(tab1, testVideoId);
+
+  info(`open same page on another tab, which shouldn't cause audio competing`);
+  const tab2 = await createLoadedTabWrapper(PAGE_AUDIBLE, { needCheck: false });
+  await checkOrWaitUntilMediaStartedPlaying(tab2, testVideoId);
+
+  info(`media in tab1 should be playing still`);
+  await checkOrWaitUntilMediaStartedPlaying(tab1, testVideoId);
+
+  info(`remove tabs`);
+  await clearTabsAndResetPref([tab1, tab2]);
+});
+
+add_task(async function testEnableAudioFocusManagement() {
+  await switchAudioFocusManagerment(true);
+
+  info(`open audible autoplay media in tab1`);
+  const tab1 = await createLoadedTabWrapper(PAGE_AUDIBLE, { needCheck: false });
+  await checkOrWaitUntilMediaStartedPlaying(tab1, testVideoId);
+
+  info(`open same page on another tab, which should cause audio competing`);
+  const tab2 = await createLoadedTabWrapper(PAGE_AUDIBLE, { needCheck: false });
+  await checkOrWaitUntilMediaStartedPlaying(tab2, testVideoId);
+
+  info(`media in tab1 should be stopped`);
+  await checkOrWaitUntilMediaStoppedPlaying(tab1, testVideoId);
+
+  info(`remove tabs`);
+  await clearTabsAndResetPref([tab1, tab2]);
+});
+
+add_task(async function testCheckAudioCompetingMultipleTimes() {
+  await switchAudioFocusManagerment(true);
+
+  info(`open audible autoplay media in tab1`);
+  const tab1 = await createLoadedTabWrapper(PAGE_AUDIBLE, { needCheck: false });
+  await checkOrWaitUntilMediaStartedPlaying(tab1, testVideoId);
+
+  info(`open same page on another tab, which should cause audio competing`);
+  const tab2 = await createLoadedTabWrapper(PAGE_AUDIBLE, { needCheck: false });
+  await checkOrWaitUntilMediaStartedPlaying(tab2, testVideoId);
+
+  info(`media in tab1 should be stopped`);
+  await checkOrWaitUntilMediaStoppedPlaying(tab1, testVideoId);
+
+  info(`play media in tab1 again`);
+  await playMedia(tab1);
+
+  info(`media in tab2 should be stopped`);
+  await checkOrWaitUntilMediaStoppedPlaying(tab2, testVideoId);
+
+  info(`play media in tab2 again`);
+  await playMedia(tab2);
+
+  info(`media in tab1 should be stopped`);
+  await checkOrWaitUntilMediaStoppedPlaying(tab1, testVideoId);
+
+  info(`remove tabs`);
+  await clearTabsAndResetPref([tab1, tab2]);
+});
+
+add_task(async function testMutedMediaWontInvolveAudioCompeting() {
+  await switchAudioFocusManagerment(true);
+
+  info(`open audible autoplay media in tab1`);
+  const tab1 = await createLoadedTabWrapper(PAGE_AUDIBLE, { needCheck: false });
+  await checkOrWaitUntilMediaStartedPlaying(tab1, testVideoId);
+
+  info(
+    `open inaudible media page on another tab, which shouldn't cause audio competing`
+  );
+  const tab2 = await createLoadedTabWrapper(PAGE_INAUDIBLE, {
+    needCheck: false,
+  });
+  await checkOrWaitUntilMediaStartedPlaying(tab2, testVideoId);
+
+  info(`media in tab1 should be playing still`);
+  await checkOrWaitUntilMediaStartedPlaying(tab1, testVideoId);
+
+  info(
+    `open audible media page on the third tab, which should cause audio competing`
+  );
+  const tab3 = await createLoadedTabWrapper(PAGE_AUDIBLE, { needCheck: false });
+  await checkOrWaitUntilMediaStartedPlaying(tab3, testVideoId);
+
+  info(`media in tab1 should be stopped`);
+  await checkOrWaitUntilMediaStoppedPlaying(tab1, testVideoId);
+
+  info(`media in tab2 should not be affected because it's inaudible.`);
+  await checkOrWaitUntilMediaStartedPlaying(tab2, testVideoId);
+
+  info(`remove tabs`);
+  await clearTabsAndResetPref([tab1, tab2, tab3]);
+});
+
+add_task(async function testStopMultipleTabsWhenSwitchingPrefDynamically() {
+  await switchAudioFocusManagerment(false);
+
+  info(`open audible autoplay media in tab1`);
+  const tab1 = await createLoadedTabWrapper(PAGE_AUDIBLE, { needCheck: false });
+  await checkOrWaitUntilMediaStartedPlaying(tab1, testVideoId);
+
+  info(`open same page on another tab, which shouldn't cause audio competing`);
+  const tab2 = await createLoadedTabWrapper(PAGE_AUDIBLE, { needCheck: false });
+  await checkOrWaitUntilMediaStartedPlaying(tab2, testVideoId);
+
+  await switchAudioFocusManagerment(true);
+
+  info(`open same page on the third tab, which should cause audio competing`);
+  const tab3 = await createLoadedTabWrapper(PAGE_AUDIBLE, { needCheck: false });
+  await checkOrWaitUntilMediaStartedPlaying(tab3, testVideoId);
+
+  info(`media in tab1 and tab2 should be stopped`);
+  await checkOrWaitUntilMediaStoppedPlaying(tab1, testVideoId);
+  await checkOrWaitUntilMediaStoppedPlaying(tab2, testVideoId);
+
+  info(`remove tabs`);
+  await clearTabsAndResetPref([tab1, tab2, tab3]);
+});
+
+/**
+ * The following are helper funcions.
+ */
+async function switchAudioFocusManagerment(enable) {
+  const state = enable ? "Enable" : "Disable";
+  info(`${state} audio focus management`);
+  await SpecialPowers.pushPrefEnv({
+    set: [["media.audioFocus.management", enable]],
+  });
+}
+
+async function playMedia(tab) {
+  await SpecialPowers.spawn(tab.linkedBrowser, [], () => {
+    return new Promise(resolve => {
+      const video = content.document.getElementById("autoplay");
+      if (!video) {
+        ok(false, `can't get the media element!`);
+      }
+
+      ok(video.paused, `media has not started yet`);
+      info(`wait until media starts playing`);
+      video.play();
+      video.onplaying = () => {
+        video.onplaying = null;
+        ok(true, `media started playing`);
+        resolve();
+      };
+    });
+  });
+}
+
+async function clearTabsAndResetPref(tabs) {
+  info(`clear tabs and reset pref`);
+  for (let tab of tabs) {
+    await tab.close();
+  }
+  await switchAudioFocusManagerment(false);
+}
diff --git a/dom/media/mediacontrol/tests/browser/browser_control_page_with_audible_and_inaudible_media.js b/dom/media/mediacontrol/tests/browser/browser_control_page_with_audible_and_inaudible_media.js
new file mode 100644
index 0000000000..6d9bc38b04
--- /dev/null
+++ b/dom/media/mediacontrol/tests/browser/browser_control_page_with_audible_and_inaudible_media.js
@@ -0,0 +1,94 @@
+const PAGE_URL =
+  "https://example.com/browser/dom/media/mediacontrol/tests/browser/file_audio_and_inaudible_media.html";
+
+add_task(async function setupTestingPref() {
+  await SpecialPowers.pushPrefEnv({
+    set: [["media.mediacontrol.testingevents.enabled", true]],
+  });
+});
+
+/**
+ * When a page has audible media and inaudible media playing at the same time,
+ * only audible media should be controlled by media control keys. However, once
+ * inaudible media becomes audible, then it should be able to be controlled.
+ */
+add_task(async function testSetPositionState() {
+  info(`open media page`);
+  const tab = await createLoadedTabWrapper(PAGE_URL);
+
+  info(`play video1 (audible) and video2 (inaudible)`);
+  await playBothAudibleAndInaudibleMedia(tab);
+
+  info(`pressing 'pause' should only affect video1 (audible)`);
+  await generateMediaControlKeyEvent("pause");
+  await checkMediaPausedState(tab, {
+    shouldVideo1BePaused: true,
+    shouldVideo2BePaused: false,
+  });
+
+  info(`make video2 become audible, then it would be able to be controlled`);
+  await unmuteInaudibleMedia(tab);
+
+  info(`pressing 'pause' should affect video2 (audible`);
+  await generateMediaControlKeyEvent("pause");
+  await checkMediaPausedState(tab, {
+    shouldVideo1BePaused: true,
+    shouldVideo2BePaused: true,
+  });
+
+  info(`remove tab`);
+  await tab.close();
+});
+
+/**
+ * The following are helper functions.
+ */
+async function playBothAudibleAndInaudibleMedia(tab) {
+  const playbackStateChangedPromise = waitUntilDisplayedPlaybackChanged();
+  await SpecialPowers.spawn(tab.linkedBrowser, [], () => {
+    const videos = content.document.getElementsByTagName("video");
+    let promises = [];
+    for (let video of videos) {
+      info(`play ${video.id} video`);
+      promises.push(video.play());
+    }
+    return Promise.all(promises);
+  });
+  await playbackStateChangedPromise;
+}
+
+function checkMediaPausedState(
+  tab,
+  { shouldVideo1BePaused, shouldVideo2BePaused }
+) {
+  return SpecialPowers.spawn(
+    tab.linkedBrowser,
+    [shouldVideo1BePaused, shouldVideo2BePaused],
+    (shouldVideo1BePaused, shouldVideo2BePaused) => {
+      const video1 = content.document.getElementById("video1");
+      const video2 = content.document.getElementById("video2");
+      is(
+        video1.paused,
+        shouldVideo1BePaused,
+        "Correct paused state for video1"
+      );
+      is(
+        video2.paused,
+        shouldVideo2BePaused,
+        "Correct paused state for video2"
+      );
+    }
+  );
+}
+
+function unmuteInaudibleMedia(tab) {
+  const unmutePromise = SpecialPowers.spawn(tab.linkedBrowser, [], () => {
+    const video2 = content.document.getElementById("video2");
+    video2.muted = false;
+  });
+  // Inaudible media was not controllable, so it won't affect the controller's
+  // playback state. However, when it becomes audible, which means being able to
+  // be controlled by media controller, it would make the playback state chanege
+  // to `playing` because now we have an audible playinng media in the page.
+  return Promise.all([unmutePromise, waitUntilDisplayedPlaybackChanged()]);
+}
diff --git a/dom/media/mediacontrol/tests/browser/browser_default_action_handler.js b/dom/media/mediacontrol/tests/browser/browser_default_action_handler.js
new file mode 100644
index 0000000000..c33c08b0c2
--- /dev/null
+++ b/dom/media/mediacontrol/tests/browser/browser_default_action_handler.js
@@ -0,0 +1,422 @@
+const PAGE_URL =
+  "https://example.com/browser/dom/media/mediacontrol/tests/browser/file_non_autoplay.html";
+const PAGE2_URL =
+  "https://example.com/browser/dom/media/mediacontrol/tests/browser/file_main_frame_with_multiple_child_session_frames.html";
+const IFRAME_URL =
+  "https://example.com/browser/dom/media/mediacontrol/tests/browser/file_iframe_media.html";
+const CORS_IFRAME_URL =
+  "https://example.org/browser/dom/media/mediacontrol/tests/browser/file_iframe_media.html";
+const CORS_IFRAME2_URL =
+  "https://test1.example.org/browser/dom/media/mediacontrol/tests/browser/file_iframe_media.html";
+const videoId = "video";
+
+/**
+ * This test is used to check the scenario when we should use the customized
+ * action handler and the the default action handler (play/pause/stop).
+ * If a frame (DOM Window, it could be main frame or an iframe) has active media
+ * session, then it should use the customized action handler it it has one.
+ * Otherwise, the default action handler should be used.
+ */
+add_task(async function setupTestingPref() {
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      ["dom.media.mediasession.enabled", true],
+      ["media.mediacontrol.testingevents.enabled", true],
+    ],
+  });
+});
+
+add_task(async function triggerDefaultActionHandler() {
+  // Default handler should be triggered no matter if media session exists or not.
+  const kCreateMediaSession = [true, false];
+  for (const shouldCreateSession of kCreateMediaSession) {
+    info(`open page and start media`);
+    const tab = await createLoadedTabWrapper(PAGE_URL);
+    await playMedia(tab, videoId);
+
+    if (shouldCreateSession) {
+      info(
+        `media has started, so created session should become active session`
+      );
+      await Promise.all([
+        waitUntilActiveMediaSessionChanged(),
+        createMediaSession(tab),
+      ]);
+    }
+
+    info(`test 'pause' action`);
+    await simulateMediaAction(tab, "pause");
+
+    info(`default action handler should pause media`);
+    await checkOrWaitUntilMediaPauses(tab, { videoId });
+
+    info(`test 'play' action`);
+    await simulateMediaAction(tab, "play");
+
+    info(`default action handler should resume media`);
+    await checkOrWaitUntilMediaPlays(tab, { videoId });
+
+    info(`test 'stop' action`);
+    await simulateMediaAction(tab, "stop");
+
+    info(`default action handler should pause media`);
+    await checkOrWaitUntilMediaPauses(tab, { videoId });
+
+    const controller = tab.linkedBrowser.browsingContext.mediaController;
+    ok(
+      !controller.isActive,
+      `controller should be deactivated after receiving stop`
+    );
+
+    info(`remove tab`);
+    await tab.close();
+  }
+});
+
+add_task(async function triggerNonDefaultHandlerWhenSetCustomizedHandler() {
+  info(`open page and start media`);
+  const tab = await createLoadedTabWrapper(PAGE_URL);
+  await Promise.all([
+    new Promise(r => (tab.controller.onactivated = r)),
+    startMedia(tab, { videoId }),
+  ]);
+
+  const kActions = ["play", "pause", "stop"];
+  for (const action of kActions) {
+    info(`set action handler for '${action}'`);
+    await setActionHandler(tab, action);
+
+    info(`press '${action}' should trigger action handler (not a default one)`);
+    await simulateMediaAction(tab, action);
+    await waitUntilActionHandlerIsTriggered(tab, action);
+
+    info(`action handler doesn't pause media, media should keep playing`);
+    await checkOrWaitUntilMediaPlays(tab, { videoId });
+  }
+
+  info(`remove tab`);
+  await tab.close();
+});
+
+add_task(
+  async function triggerDefaultHandlerToPausePlaybackOnInactiveSession() {
+    const kIframeUrls = [IFRAME_URL, CORS_IFRAME_URL];
+    for (const url of kIframeUrls) {
+      const kActions = ["play", "pause", "stop"];
+      for (const action of kActions) {
+        info(`open page and load iframe`);
+        const tab = await createLoadedTabWrapper(PAGE_URL);
+        const frameId = "iframe";
+        await loadIframe(tab, frameId, url);
+
+        info(`start media from iframe would make it become active session`);
+        await Promise.all([
+          new Promise(r => (tab.controller.onactivated = r)),
+          startMedia(tab, { frameId }),
+        ]);
+
+        info(`press '${action}' should trigger iframe's action handler`);
+        await setActionHandler(tab, action, frameId);
+        await simulateMediaAction(tab, action);
+        await waitUntilActionHandlerIsTriggered(tab, action, frameId);
+
+        info(`start media from main frame so iframe would become inactive`);
+        // When action is `play`, controller is already playing, because above
+        // code won't pause media. So we need to wait for the active session
+        // changed to ensure the following tests can be executed on the right
+        // browsing context.
+        let waitForControllerStatusChanged =
+          action == "play"
+            ? waitUntilActiveMediaSessionChanged()
+            : ensureControllerIsPlaying(tab.controller);
+        await Promise.all([
+          waitForControllerStatusChanged,
+          startMedia(tab, { videoId }),
+        ]);
+
+        if (action == "play") {
+          info(`pause media first in order to test 'play'`);
+          await pauseAllMedia(tab);
+
+          info(
+            `press '${action}' would trigger default andler on main frame because it doesn't set action handler`
+          );
+          await simulateMediaAction(tab, action);
+          await checkOrWaitUntilMediaPlays(tab, { videoId });
+
+          info(
+            `default handler should also be triggered on inactive iframe, which would resume media`
+          );
+          await checkOrWaitUntilMediaPlays(tab, { frameId });
+        } else {
+          info(
+            `press '${action}' would trigger default andler on main frame because it doesn't set action handler`
+          );
+          await simulateMediaAction(tab, action);
+          await checkOrWaitUntilMediaPauses(tab, { videoId });
+
+          info(
+            `default handler should also be triggered on inactive iframe, which would pause media`
+          );
+          await checkOrWaitUntilMediaPauses(tab, { frameId });
+        }
+
+        info(`remove tab`);
+        await tab.close();
+      }
+    }
+  }
+);
+
+add_task(async function onlyResumeActiveMediaSession() {
+  info(`open page and load iframes`);
+  const tab = await createLoadedTabWrapper(PAGE2_URL);
+  const frame1Id = "frame1";
+  const frame2Id = "frame2";
+  await loadIframe(tab, frame1Id, CORS_IFRAME_URL);
+  await loadIframe(tab, frame2Id, CORS_IFRAME2_URL);
+
+  info(`start media from iframe1 would make it become active session`);
+  await createMediaSession(tab, frame1Id);
+  await Promise.all([
+    waitUntilActiveMediaSessionChanged(),
+    startMedia(tab, { frameId: frame1Id }),
+  ]);
+
+  info(`start media from iframe2 would make it become active session`);
+  await createMediaSession(tab, frame2Id);
+  await Promise.all([
+    waitUntilActiveMediaSessionChanged(),
+    startMedia(tab, { frameId: frame2Id }),
+  ]);
+
+  info(`press 'pause' should pause both iframes`);
+  await simulateMediaAction(tab, "pause");
+  await checkOrWaitUntilMediaPauses(tab, { frameId: frame1Id });
+  await checkOrWaitUntilMediaPauses(tab, { frameId: frame2Id });
+
+  info(
+    `press 'play' should only resume iframe2 which has active media session`
+  );
+  await simulateMediaAction(tab, "play");
+  await checkOrWaitUntilMediaPauses(tab, { frameId: frame1Id });
+  await checkOrWaitUntilMediaPlays(tab, { frameId: frame2Id });
+
+  info(`remove tab`);
+  await tab.close();
+});
+
+/**
+ * The following are helper functions.
+ */
+function startMedia(tab, { videoId, frameId }) {
+  return SpecialPowers.spawn(
+    tab.linkedBrowser,
+    [videoId, frameId],
+    (videoId, frameId) => {
+      if (frameId) {
+        return content.messageHelper(
+          content.document.getElementById(frameId),
+          "play",
+          "played"
+        );
+      }
+      return content.document.getElementById(videoId).play();
+    }
+  );
+}
+
+function pauseAllMedia(tab) {
+  return SpecialPowers.spawn(tab.linkedBrowser, [], async () => {
+    await content.messageHelper(
+      content.document.getElementById("iframe"),
+      "pause",
+      "paused"
+    );
+    const videos = content.document.getElementsByTagName("video");
+    for (let video of videos) {
+      video.pause();
+    }
+  });
+}
+
+function createMediaSession(tab, frameId = null) {
+  info(`create media session`);
+  return SpecialPowers.spawn(tab.linkedBrowser, [frameId], async frameId => {
+    if (frameId) {
+      await content.messageHelper(
+        content.document.getElementById(frameId),
+        "create-media-session",
+        "created-media-session"
+      );
+      return;
+    }
+    // simply calling a media session would create an instance.
+    content.navigator.mediaSession;
+  });
+}
+
+function checkOrWaitUntilMediaPauses(tab, { videoId, frameId }) {
+  return SpecialPowers.spawn(
+    tab.linkedBrowser,
+    [videoId, frameId],
+    (videoId, frameId) => {
+      if (frameId) {
+        return content.messageHelper(
+          content.document.getElementById(frameId),
+          "check-pause",
+          "checked-pause"
+        );
+      }
+      return new Promise(r => {
+        const video = content.document.getElementById(videoId);
+        if (video.paused) {
+          ok(true, `media stopped playing`);
+          r();
+        } else {
+          info(`wait until media stops playing`);
+          video.onpause = () => {
+            video.onpause = null;
+            ok(true, `media stopped playing`);
+            r();
+          };
+        }
+      });
+    }
+  );
+}
+
+function checkOrWaitUntilMediaPlays(tab, { videoId, frameId }) {
+  return SpecialPowers.spawn(
+    tab.linkedBrowser,
+    [videoId, frameId],
+    (videoId, frameId) => {
+      if (frameId) {
+        return content.messageHelper(
+          content.document.getElementById(frameId),
+          "check-playing",
+          "checked-playing"
+        );
+      }
+      return new Promise(r => {
+        const video = content.document.getElementById(videoId);
+        if (!video.paused) {
+          ok(true, `media is playing`);
+          r();
+        } else {
+          info(`wait until media starts playing`);
+          video.onplay = () => {
+            video.onplay = null;
+            ok(true, `media starts playing`);
+            r();
+          };
+        }
+      });
+    }
+  );
+}
+
+function setActionHandler(tab, action, frameId = null) {
+  return SpecialPowers.spawn(
+    tab.linkedBrowser,
+    [action, frameId],
+    async (action, frameId) => {
+      if (frameId) {
+        await content.messageHelper(
+          content.document.getElementById(frameId),
+          {
+            cmd: "setActionHandler",
+            action,
+          },
+          "setActionHandler-done"
+        );
+        return;
+      }
+      // Create this on the first function call
+      if (content.actionHandlerPromises === undefined) {
+        content.actionHandlerPromises = {};
+      }
+      content.actionHandlerPromises[action] = new Promise(r => {
+        content.navigator.mediaSession.setActionHandler(action, () => {
+          info(`receive ${action}`);
+          r();
+        });
+      });
+    }
+  );
+}
+
+async function waitUntilActionHandlerIsTriggered(tab, action, frameId = null) {
+  info(`wait until '${action}' action handler is triggered`);
+  return SpecialPowers.spawn(
+    tab.linkedBrowser,
+    [action, frameId],
+    (action, frameId) => {
+      if (frameId) {
+        return content.messageHelper(
+          content.document.getElementById(frameId),
+          {
+            cmd: "checkActionHandler",
+            action,
+          },
+          "checkActionHandler-done"
+        );
+      }
+      const actionTriggerPromise = content.actionHandlerPromises[action];
+      ok(actionTriggerPromise, `Has created promise for ${action}`);
+      return actionTriggerPromise;
+    }
+  );
+}
+
+async function simulateMediaAction(tab, action) {
+  const controller = tab.linkedBrowser.browsingContext.mediaController;
+  if (!controller.isActive) {
+    await new Promise(r => (controller.onactivated = r));
+  }
+  MediaControlService.generateMediaControlKey(action);
+}
+
+function loadIframe(tab, iframeId, url) {
+  return SpecialPowers.spawn(
+    tab.linkedBrowser,
+    [iframeId, url],
+    async (iframeId, url) => {
+      const iframe = content.document.getElementById(iframeId);
+      info(`load iframe with url '${url}'`);
+      iframe.src = url;
+      await new Promise(r => (iframe.onload = r));
+      // create a helper to simplify communication process with iframe
+      content.messageHelper = (target, sentMessage, expectedResponse) => {
+        target.contentWindow.postMessage(sentMessage, "*");
+        return new Promise(r => {
+          content.onmessage = event => {
+            if (event.data == expectedResponse) {
+              ok(true, `Received response ${expectedResponse}`);
+              content.onmessage = null;
+              r();
+            }
+          };
+        });
+      };
+    }
+  );
+}
+
+function waitUntilActiveMediaSessionChanged() {
+  return BrowserUtils.promiseObserved("active-media-session-changed");
+}
+
+function ensureControllerIsPlaying(controller) {
+  return new Promise(r => {
+    if (controller.isPlaying) {
+      r();
+      return;
+    }
+    controller.onplaybackstatechange = () => {
+      if (controller.isPlaying) {
+        r();
+      }
+    };
+  });
+}
diff --git a/dom/media/mediacontrol/tests/browser/browser_media_control_audio_focus_within_a_page.js b/dom/media/mediacontrol/tests/browser/browser_media_control_audio_focus_within_a_page.js
new file mode 100644
index 0000000000..5db37059dd
--- /dev/null
+++ b/dom/media/mediacontrol/tests/browser/browser_media_control_audio_focus_within_a_page.js
@@ -0,0 +1,358 @@
+const mainPageURL =
+  "https://example.com/browser/dom/media/mediacontrol/tests/browser/file_main_frame_with_multiple_child_session_frames.html";
+const frameURL =
+  "https://example.com/browser/dom/media/mediacontrol/tests/browser/file_iframe_media.html";
+
+const frame1 = "frame1";
+const frame2 = "frame2";
+
+add_task(async function setupTestingPref() {
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      ["media.mediacontrol.testingevents.enabled", true],
+      ["dom.media.mediasession.enabled", true],
+    ],
+  });
+});
+
+/**
+ * This test is used to check the behaviors when we play media from different
+ * frames. When a page contains multiple frames, if those frames are using the
+ * media session and set the metadata, then we have to know which frame owns the
+ * audio focus that would be the last tab playing media. When the frame owns
+ * audio focus, it means its metadata would be displayed on the virtual control
+ * interface if it has a media session.
+ */
+add_task(async function testAudioFocusChangesAmongMultipleFrames() {
+  /**
+   * Play the media from the main frame, so it would own the audio focus and
+   * its metadata should be shown on the virtual control interface. As the main
+   * frame doesn't use media session, the current metadata would be the default
+   * metadata.
+   */
+  const tab = await createLoadedTabWrapper(mainPageURL);
+  await playAndWaitUntilMetadataChanged(tab);
+  await isGivenTabUsingDefaultMetadata(tab);
+
+  /**
+   * Play media for frame1, so the audio focus switches to frame1 because it's
+   * the last tab playing media and frame1's metadata should be displayed.
+   */
+  await loadPageForFrame(tab, frame1, frameURL);
+  let metadata = await setMetadataAndGetReturnResult(tab, frame1);
+  await playAndWaitUntilMetadataChanged(tab, frame1);
+  isCurrentMetadataEqualTo(metadata);
+
+  /**
+   * Play media for frame2, so the audio focus switches to frame2 because it's
+   * the last tab playing media and frame2's metadata should be displayed.
+   */
+  await loadPageForFrame(tab, frame2, frameURL);
+  metadata = await setMetadataAndGetReturnResult(tab, frame2);
+  await playAndWaitUntilMetadataChanged(tab, frame2);
+  isCurrentMetadataEqualTo(metadata);
+
+  /**
+   * Remove tab and end test.
+   */
+  await tab.close();
+});
+
+add_task(async function testAudioFocusChangesAfterPausingAudioFocusOwner() {
+  /**
+   * Play the media from the main frame, so it would own the audio focus and
+   * its metadata should be shown on the virtual control interface. As the main
+   * frame doesn't use media session, the current metadata would be the default
+   * metadata.
+   */
+  const tab = await createLoadedTabWrapper(mainPageURL);
+  await playAndWaitUntilMetadataChanged(tab);
+  await isGivenTabUsingDefaultMetadata(tab);
+
+  /**
+   * Play media for frame1, so the audio focus switches to frame1 because it's
+   * the last tab playing media and frame1's metadata should be displayed.
+   */
+  await loadPageForFrame(tab, frame1, frameURL);
+  let metadata = await setMetadataAndGetReturnResult(tab, frame1);
+  await playAndWaitUntilMetadataChanged(tab, frame1);
+  isCurrentMetadataEqualTo(metadata);
+
+  /**
+   * Pause media for frame1, so the audio focus switches back to the main frame
+   * which is still playing media.
+   */
+  await pauseAndWaitUntilMetadataChangedFrom(tab, frame1);
+  await isGivenTabUsingDefaultMetadata(tab);
+
+  /**
+   * Remove tab and end test.
+   */
+  await tab.close();
+});
+
+add_task(async function testAudioFocusUnchangesAfterPausingAudioFocusOwner() {
+  /**
+   * Play the media from the main frame, so it would own the audio focus and
+   * its metadata should be shown on the virtual control interface. As the main
+   * frame doesn't use media session, the current metadata would be the default
+   * metadata.
+   */
+  const tab = await createLoadedTabWrapper(mainPageURL);
+  await playAndWaitUntilMetadataChanged(tab);
+  await isGivenTabUsingDefaultMetadata(tab);
+
+  /**
+   * Play media for frame1, so the audio focus switches to frame1 because it's
+   * the last tab playing media and frame1's metadata should be displayed.
+   */
+  await loadPageForFrame(tab, frame1, frameURL);
+  let metadata = await setMetadataAndGetReturnResult(tab, frame1);
+  await playAndWaitUntilMetadataChanged(tab, frame1);
+  isCurrentMetadataEqualTo(metadata);
+
+  /**
+   * Pause main frame's media first. When pausing frame1's media, there are not
+   * other frames playing media, so frame1 still owns the audio focus and its
+   * metadata should be displayed.
+   */
+  await pauseMediaFrom(tab);
+  isCurrentMetadataEqualTo(metadata);
+
+  /**
+   * Remove tab and end test.
+   */
+  await tab.close();
+});
+
+add_task(
+  async function testSwitchAudioFocusToMainFrameAfterRemovingAudioFocusOwner() {
+    /**
+     * Play the media from the main frame, so it would own the audio focus and
+     * its metadata should be displayed on the virtual control interface. As the
+     * main frame doesn't use media session, the current metadata would be the
+     * default metadata.
+     */
+    const tab = await createLoadedTabWrapper(mainPageURL);
+    await playAndWaitUntilMetadataChanged(tab);
+    await isGivenTabUsingDefaultMetadata(tab);
+
+    /**
+     * Play media for frame1, so the audio focus switches to frame1 because it's
+     * the last tab playing media and frame1's metadata should be displayed.
+     */
+    await loadPageForFrame(tab, frame1, frameURL);
+    let metadata = await setMetadataAndGetReturnResult(tab, frame1);
+    await playAndWaitUntilMetadataChanged(tab, frame1);
+    isCurrentMetadataEqualTo(metadata);
+
+    /**
+     * Remove frame1, the audio focus would switch to the main frame which
+     * metadata should be displayed.
+     */
+    await Promise.all([
+      waitUntilDisplayedMetadataChanged(),
+      removeFrame(tab, frame1),
+    ]);
+    await isGivenTabUsingDefaultMetadata(tab);
+
+    /**
+     * Remove tab and end test.
+     */
+    await tab.close();
+  }
+);
+
+add_task(
+  async function testSwitchAudioFocusToIframeAfterRemovingAudioFocusOwner() {
+    /**
+     * Play media for frame1, so frame1 owns the audio focus and frame1's metadata
+     * should be displayed.
+     */
+    const tab = await createLoadedTabWrapper(mainPageURL);
+    await loadPageForFrame(tab, frame1, frameURL);
+    let metadataFrame1 = await setMetadataAndGetReturnResult(tab, frame1);
+    await playAndWaitUntilMetadataChanged(tab, frame1);
+    isCurrentMetadataEqualTo(metadataFrame1);
+
+    /**
+     * Play media for frame2, so the audio focus switches to frame2 because it's
+     * the last tab playing media and frame2's metadata should be displayed.
+     */
+    await loadPageForFrame(tab, frame2, frameURL);
+    let metadataFrame2 = await setMetadataAndGetReturnResult(tab, frame2);
+    await playAndWaitUntilMetadataChanged(tab, frame2);
+    isCurrentMetadataEqualTo(metadataFrame2);
+
+    /**
+     * Remove frame2, the audio focus would switch to frame1 which metadata should
+     * be displayed.
+     */
+    await Promise.all([
+      waitUntilDisplayedMetadataChanged(),
+      removeFrame(tab, frame2),
+    ]);
+    isCurrentMetadataEqualTo(metadataFrame1);
+
+    /**
+     * Remove tab and end test.
+     */
+    await tab.close();
+  }
+);
+
+add_task(async function testNoAudioFocusAfterRemovingAudioFocusOwner() {
+  /**
+   * Play the media from the main frame, so it would own the audio focus and
+   * its metadata should be shown on the virtual control interface. As the main
+   * frame doesn't use media session, the current metadata would be the default
+   * metadata.
+   */
+  const tab = await createLoadedTabWrapper(mainPageURL);
+  await playAndWaitUntilMetadataChanged(tab);
+  await isGivenTabUsingDefaultMetadata(tab);
+
+  /**
+   * Play media for frame1, so the audio focus switches to frame1 because it's
+   * the last tab playing media and frame1's metadata should be displayed.
+   */
+  await loadPageForFrame(tab, frame1, frameURL);
+  let metadata = await setMetadataAndGetReturnResult(tab, frame1);
+  await playAndWaitUntilMetadataChanged(tab, frame1);
+  isCurrentMetadataEqualTo(metadata);
+
+  /**
+   * Pause media in main frame and then remove frame1. As the frame which owns
+   * the audio focus is removed and no frame is still playing media, the current
+   * metadata would be the default metadata.
+   */
+  await pauseMediaFrom(tab);
+  await Promise.all([
+    waitUntilDisplayedMetadataChanged(),
+    removeFrame(tab, frame1),
+  ]);
+  await isGivenTabUsingDefaultMetadata(tab);
+
+  /**
+   * Remove tab and end test.
+   */
+  await tab.close();
+});
+
+/**
+ * The following are helper functions.
+ */
+function loadPageForFrame(tab, frameId, pageUrl) {
+  info(`start to load page for ${frameId}`);
+  return SpecialPowers.spawn(
+    tab.linkedBrowser,
+    [frameId, pageUrl],
+    async (id, url) => {
+      const iframe = content.document.getElementById(id);
+      if (!iframe) {
+        ok(false, `can not get iframe '${id}'`);
+      }
+      iframe.src = url;
+      await new Promise(r => (iframe.onload = r));
+      // Set the document title that would be used as the value for properties
+      // in frame's medadata.
+      iframe.contentDocument.title = id;
+    }
+  );
+}
+
+function playMediaFrom(tab, frameId = undefined) {
+  return SpecialPowers.spawn(tab.linkedBrowser, [frameId], id => {
+    if (id == undefined) {
+      info(`start to play media from main frame`);
+      const video = content.document.getElementById("video");
+      if (!video) {
+        ok(false, `can't get the media element!`);
+      }
+      return video.play();
+    }
+
+    info(`start to play media from ${id}`);
+    const iframe = content.document.getElementById(id);
+    if (!iframe) {
+      ok(false, `can not get ${id}`);
+    }
+    iframe.contentWindow.postMessage("play", "*");
+    return new Promise(r => {
+      content.onmessage = event => {
+        is(event.data, "played", `media started playing in ${id}`);
+        r();
+      };
+    });
+  });
+}
+
+function playAndWaitUntilMetadataChanged(tab, frameId = undefined) {
+  const metadataChanged = frameId
+    ? new Promise(r => (tab.controller.onmetadatachange = r))
+    : waitUntilDisplayedMetadataChanged();
+  return Promise.all([metadataChanged, playMediaFrom(tab, frameId)]);
+}
+
+function pauseMediaFrom(tab, frameId = undefined) {
+  return SpecialPowers.spawn(tab.linkedBrowser, [frameId], id => {
+    if (id == undefined) {
+      info(`start to pause media from in frame`);
+      const video = content.document.getElementById("video");
+      if (!video) {
+        ok(false, `can't get the media element!`);
+      }
+      return video.pause();
+    }
+
+    info(`start to pause media in ${id}`);
+    const iframe = content.document.getElementById(id);
+    if (!iframe) {
+      ok(false, `can not get ${id}`);
+    }
+    iframe.contentWindow.postMessage("pause", "*");
+    return new Promise(r => {
+      content.onmessage = event => {
+        is(event.data, "paused", `media paused in ${id}`);
+        r();
+      };
+    });
+  });
+}
+
+function pauseAndWaitUntilMetadataChangedFrom(tab, frameId = undefined) {
+  const metadataChanged = waitUntilDisplayedMetadataChanged();
+  return Promise.all([metadataChanged, pauseMediaFrom(tab, frameId)]);
+}
+
+function setMetadataAndGetReturnResult(tab, frameId) {
+  info(`start to set metadata for ${frameId}`);
+  return SpecialPowers.spawn(tab.linkedBrowser, [frameId], id => {
+    const iframe = content.document.getElementById(id);
+    if (!iframe) {
+      ok(false, `can not get ${id}`);
+    }
+    iframe.contentWindow.postMessage("setMetadata", "*");
+    info(`wait until we get metadata for ${id}`);
+    return new Promise(r => {
+      content.onmessage = event => {
+        ok(
+          event.data.title && event.data.artist && event.data.album,
+          "correct return format"
+        );
+        r(event.data);
+      };
+    });
+  });
+}
+
+function removeFrame(tab, frameId) {
+  info(`remove ${frameId}`);
+  return SpecialPowers.spawn(tab.linkedBrowser, [frameId], id => {
+    const iframe = content.document.getElementById(id);
+    if (!iframe) {
+      ok(false, `can not get ${id}`);
+    }
+    content.document.body.removeChild(iframe);
+  });
+}
diff --git a/dom/media/mediacontrol/tests/browser/browser_media_control_before_media_starts.js b/dom/media/mediacontrol/tests/browser/browser_media_control_before_media_starts.js
new file mode 100644
index 0000000000..292c2f521f
--- /dev/null
+++ b/dom/media/mediacontrol/tests/browser/browser_media_control_before_media_starts.js
@@ -0,0 +1,205 @@
+// Import this in order to use `triggerPictureInPicture()`.
+Services.scriptloader.loadSubScript(
+  "chrome://mochitests/content/browser/toolkit/components/pictureinpicture/tests/head.js",
+  this
+);
+
+const PAGE_NON_AUTOPLAY =
+  "https://example.com/browser/dom/media/mediacontrol/tests/browser/file_non_autoplay.html";
+const IFRAME_URL =
+  "https://example.com/browser/dom/media/mediacontrol/tests/browser/file_iframe_media.html";
+const testVideoId = "video";
+
+add_task(async function setupTestingPref() {
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      ["media.mediacontrol.testingevents.enabled", true],
+      ["full-screen-api.allow-trusted-requests-only", false],
+    ],
+  });
+});
+
+/**
+ * Usually we would only start controlling media after media starts, but if
+ * media has entered Picture-in-Picture mode or fullscreen, then we would allow
+ * users to control them directly without prior to starting media.
+ */
+add_task(async function testMediaEntersPIPMode() {
+  info(`open media page`);
+  const tab = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY);
+
+  info(`trigger PIP mode`);
+  const winPIP = await triggerPictureInPicture(tab.linkedBrowser, testVideoId);
+
+  info(`press 'play' and wait until media starts`);
+  await generateMediaControlKeyEvent("play");
+  await checkOrWaitUntilMediaStartedPlaying(tab, testVideoId);
+
+  info(`remove tab`);
+  await BrowserTestUtils.closeWindow(winPIP);
+  await tab.close();
+});
+
+add_task(async function testMutedMediaEntersPIPMode() {
+  info(`open media page and mute video`);
+  const tab = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY);
+  await muteMedia(tab, testVideoId);
+
+  info(`trigger PIP mode`);
+  const winPIP = await triggerPictureInPicture(tab.linkedBrowser, testVideoId);
+
+  info(`press 'play' and wait until media starts`);
+  await generateMediaControlKeyEvent("play");
+  await checkOrWaitUntilMediaStartedPlaying(tab, testVideoId);
+
+  info(`remove tab`);
+  await BrowserTestUtils.closeWindow(winPIP);
+  await tab.close();
+});
+
+add_task(async function testMediaEntersFullScreen() {
+  info(`open media page`);
+  const tab = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY);
+
+  info(`make video fullscreen`);
+  await enableFullScreen(tab, testVideoId);
+
+  info(`press 'play' and wait until media starts`);
+  await generateMediaControlKeyEvent("play");
+  await checkOrWaitUntilMediaStartedPlaying(tab, testVideoId);
+
+  info(`remove tab`);
+  await tab.close();
+});
+
+add_task(async function testMutedMediaEntersFullScreen() {
+  info(`open media page and mute video`);
+  const tab = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY);
+  await muteMedia(tab, testVideoId);
+
+  info(`make video fullscreen`);
+  await enableFullScreen(tab, testVideoId);
+
+  info(`press 'play' and wait until media starts`);
+  await generateMediaControlKeyEvent("play");
+  await checkOrWaitUntilMediaStartedPlaying(tab, testVideoId);
+
+  info(`remove tab`);
+  await tab.close();
+});
+
+add_task(async function testNonMediaEntersFullScreen() {
+  info(`open media page which won't have an activated controller`);
+  // As we won't activate controller in this test case, not need to
+  // check controller's status.
+  const tab = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY, {
+    needCheck: false,
+  });
+
+  info(`make non-media element fullscreen`);
+  const nonMediaElementId = "image";
+  await enableFullScreen(tab, nonMediaElementId);
+
+  info(`press 'play' which should not start media`);
+  // Use `generateMediaControlKey()` directly because `play` won't affect the
+  // controller's playback state (don't need to wait for the change).
+  MediaControlService.generateMediaControlKey("play");
+  await checkOrWaitUntilMediaStoppedPlaying(tab, testVideoId);
+
+  info(`remove tab`);
+  await tab.close();
+});
+
+add_task(async function testMediaInIframeEntersFullScreen() {
+  info(`open media page`);
+  const tab = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY);
+
+  info(`make video in iframe fullscreen`);
+  await enableMediaFullScreenInIframe(tab, testVideoId);
+
+  info(`press 'play' and wait until media starts`);
+  await generateMediaControlKeyEvent("play");
+
+  info(`full screen media in inframe should be started`);
+  await waitUntilIframeMediaStartedPlaying(tab);
+
+  info(`media not in fullscreen should keep paused`);
+  await checkOrWaitUntilMediaStoppedPlaying(tab, testVideoId);
+
+  info(`remove iframe that contains fullscreen video`);
+  await removeIframeFromDocument(tab);
+
+  info(`remove tab`);
+  await tab.close();
+});
+
+/**
+ * The following are helper functions.
+ */
+function muteMedia(tab, videoId) {
+  return SpecialPowers.spawn(tab.linkedBrowser, [videoId], videoId => {
+    content.document.getElementById(videoId).muted = true;
+  });
+}
+
+function enableFullScreen(tab, elementId) {
+  return SpecialPowers.spawn(tab.linkedBrowser, [elementId], elementId => {
+    return new Promise(r => {
+      const element = content.document.getElementById(elementId);
+      element.requestFullscreen();
+      element.onfullscreenchange = () => {
+        element.onfullscreenchange = null;
+        element.onfullscreenerror = null;
+        r();
+      };
+      element.onfullscreenerror = () => {
+        // Retry until the element successfully enters fullscreen.
+        element.requestFullscreen();
+      };
+    });
+  });
+}
+
+function enableMediaFullScreenInIframe(tab) {
+  return SpecialPowers.spawn(tab.linkedBrowser, [IFRAME_URL], async url => {
+    info(`create iframe and wait until it finishes loading`);
+    const iframe = content.document.getElementById("iframe");
+    iframe.src = url;
+    await new Promise(r => (iframe.onload = r));
+
+    info(`trigger media in iframe entering into fullscreen`);
+    iframe.contentWindow.postMessage("fullscreen", "*");
+    info(`wait until media in frame enters fullscreen`);
+    return new Promise(r => {
+      content.onmessage = event => {
+        is(
+          event.data,
+          "entered-fullscreen",
+          `media in iframe entered fullscreen`
+        );
+        r();
+      };
+    });
+  });
+}
+
+function waitUntilIframeMediaStartedPlaying(tab) {
+  return SpecialPowers.spawn(tab.linkedBrowser, [IFRAME_URL], async url => {
+    info(`check if media in iframe starts playing`);
+    const iframe = content.document.getElementById("iframe");
+    iframe.contentWindow.postMessage("check-playing", "*");
+    return new Promise(r => {
+      content.onmessage = event => {
+        is(event.data, "checked-playing", `media in iframe is playing`);
+        r();
+      };
+    });
+  });
+}
+
+function removeIframeFromDocument(tab) {
+  return SpecialPowers.spawn(tab.linkedBrowser, [], () => {
+    info(`remove iframe from document`);
+    content.document.getElementById("iframe").remove();
+  });
+}
diff --git a/dom/media/mediacontrol/tests/browser/browser_media_control_captured_audio.js b/dom/media/mediacontrol/tests/browser/browser_media_control_captured_audio.js
new file mode 100644
index 0000000000..0da8acd62b
--- /dev/null
+++ b/dom/media/mediacontrol/tests/browser/browser_media_control_captured_audio.js
@@ -0,0 +1,45 @@
+const PAGE_NON_AUTOPLAY_MEDIA =
+  "https://example.com/browser/dom/media/mediacontrol/tests/browser/file_non_autoplay.html";
+
+const testVideoId = "video";
+
+add_task(async function setupTestingPref() {
+  await SpecialPowers.pushPrefEnv({
+    set: [["media.mediacontrol.testingevents.enabled", true]],
+  });
+});
+
+/**
+ * When we capture audio from an media element to the web audio, if the media
+ * is audible, it should be controlled by media keys as well.
+ */
+add_task(async function testAudibleCapturedMedia() {
+  info(`open new non autoplay media page`);
+  const tab = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY_MEDIA);
+
+  info(`capture audio and start playing`);
+  await captureAudio(tab, testVideoId);
+  await playMedia(tab, testVideoId);
+
+  info(`pressing 'pause' key, captured media should be paused`);
+  await generateMediaControlKeyEvent("pause");
+  await checkOrWaitUntilMediaStoppedPlaying(tab, testVideoId);
+
+  info(`remove tab`);
+  await tab.close();
+});
+
+/**
+ * The following are helper functions.
+ */
+function captureAudio(tab, elementId) {
+  return SpecialPowers.spawn(tab.linkedBrowser, [elementId], Id => {
+    const video = content.document.getElementById(Id);
+    if (!video) {
+      ok(false, `can't get the media element!`);
+    }
+    const context = new content.AudioContext();
+    // Capture audio from the media element to a MediaElementAudioSourceNode.
+    context.createMediaElementSource(video);
+  });
+}
diff --git a/dom/media/mediacontrol/tests/browser/browser_media_control_keys_event.js b/dom/media/mediacontrol/tests/browser/browser_media_control_keys_event.js
new file mode 100644
index 0000000000..a8525e61c5
--- /dev/null
+++ b/dom/media/mediacontrol/tests/browser/browser_media_control_keys_event.js
@@ -0,0 +1,62 @@
+const PAGE =
+  "https://example.com/browser/dom/media/mediacontrol/tests/browser/file_non_autoplay.html";
+const testVideoId = "video";
+
+/**
+ * This test is used to generate platform-independent media control keys event
+ * and see if media can be controlled correctly and current we only support
+ * `play`, `pause`, `playPause` and `stop` events.
+ */
+add_task(async function setupTestingPref() {
+  await SpecialPowers.pushPrefEnv({
+    set: [["media.mediacontrol.testingevents.enabled", true]],
+  });
+});
+
+add_task(async function testPlayPauseAndStop() {
+  info(`open page and start media`);
+  const tab = await createLoadedTabWrapper(PAGE);
+  await playMedia(tab, testVideoId);
+
+  info(`pressing 'pause' key`);
+  MediaControlService.generateMediaControlKey("pause");
+  await checkOrWaitUntilMediaStoppedPlaying(tab, testVideoId);
+
+  info(`pressing 'play' key`);
+  MediaControlService.generateMediaControlKey("play");
+  await checkOrWaitUntilMediaStartedPlaying(tab, testVideoId);
+
+  info(`pressing 'stop' key`);
+  MediaControlService.generateMediaControlKey("stop");
+  await checkOrWaitUntilMediaStoppedPlaying(tab, testVideoId);
+
+  info(`Has stopped controlling media, pressing 'play' won't resume it`);
+  MediaControlService.generateMediaControlKey("play");
+  await checkOrWaitUntilMediaStoppedPlaying(tab, testVideoId);
+
+  info(`remove tab`);
+  await tab.close();
+});
+
+add_task(async function testPlayPause() {
+  info(`open page and start media`);
+  const tab = await createLoadedTabWrapper(PAGE);
+  await playMedia(tab, testVideoId);
+
+  info(`pressing 'playPause' key, media should stop`);
+  MediaControlService.generateMediaControlKey("playpause");
+  await Promise.all([
+    new Promise(r => (tab.controller.onplaybackstatechange = r)),
+    checkOrWaitUntilMediaStoppedPlaying(tab, testVideoId),
+  ]);
+
+  info(`pressing 'playPause' key, media should start`);
+  MediaControlService.generateMediaControlKey("playpause");
+  await Promise.all([
+    new Promise(r => (tab.controller.onplaybackstatechange = r)),
+    checkOrWaitUntilMediaStartedPlaying(tab, testVideoId),
+  ]);
+
+  info(`remove tab`);
+  await tab.close();
+});
diff --git a/dom/media/mediacontrol/tests/browser/browser_media_control_main_controller.js b/dom/media/mediacontrol/tests/browser/browser_media_control_main_controller.js
new file mode 100644
index 0000000000..9ddd3d7a18
--- /dev/null
+++ b/dom/media/mediacontrol/tests/browser/browser_media_control_main_controller.js
@@ -0,0 +1,341 @@
+// Import this in order to use `triggerPictureInPicture()`.
+Services.scriptloader.loadSubScript(
+  "chrome://mochitests/content/browser/toolkit/components/pictureinpicture/tests/head.js",
+  this
+);
+
+const PAGE_NON_AUTOPLAY =
+  "https://example.com/browser/dom/media/mediacontrol/tests/browser/file_non_autoplay.html";
+
+const testVideoId = "video";
+
+add_task(async function setupTestingPref() {
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      ["media.mediacontrol.testingevents.enabled", true],
+      ["dom.media.mediasession.enabled", true],
+    ],
+  });
+});
+
+/**
+ * This test is used to check in different situaition if we can determine the
+ * main controller correctly that is the controller which can receive media
+ * control keys and show its metadata on the virtual control interface.
+ *
+ * We will assign different metadata for each tab and know which tab is the main
+ * controller by checking main controller's metadata.
+ *
+ * We will always choose the last tab which plays media as the main controller,
+ * and maintain a list by the order of playing media. If the top element in the
+ * list has been removed, then we will use the last element in the list as the
+ * main controller.
+ *
+ * Eg. tab1 plays first, then tab2 plays, then tab3 plays, the list would be
+ * like [tab1, tab2, tab3] and the main controller would be tab3. If tab3 has
+ * been closed, then the list would become [tab1, tab2] and the tab2 would be
+ * the main controller.
+ */
+add_task(async function testDeterminingMainController() {
+  info(`open three different tabs`);
+  const tab0 = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY);
+  const tab1 = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY);
+  const tab2 = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY);
+
+  /**
+   * part1 : [] -> [tab0] -> [tab0, tab1] -> [tab0, tab1, tab2]
+   */
+  info(`# [] -> [tab0] -> [tab0, tab1] -> [tab0, tab1, tab2] #`);
+  info(`set different metadata for each tab`);
+  await setMediaMetadataForTabs([tab0, tab1, tab2]);
+
+  info(`start media for tab0, main controller should become tab0`);
+  await makeTabBecomeMainControllerAndWaitForMetadataChange(tab0);
+
+  info(`currrent metadata should be equal to tab0's metadata`);
+  await isCurrentMetadataEqualTo(tab0.metadata);
+
+  info(`start media for tab1, main controller should become tab1`);
+  await makeTabBecomeMainControllerAndWaitForMetadataChange(tab1);
+
+  info(`currrent metadata should be equal to tab1's metadata`);
+  await isCurrentMetadataEqualTo(tab1.metadata);
+
+  info(`start media for tab2, main controller should become tab2`);
+  await makeTabBecomeMainControllerAndWaitForMetadataChange(tab2);
+
+  info(`currrent metadata should be equal to tab2's metadata`);
+  await isCurrentMetadataEqualTo(tab2.metadata);
+
+  /**
+   * part2 : [tab0, tab1, tab2] -> [tab0, tab2, tab1] -> [tab2, tab1, tab0]
+   */
+  info(`# [tab0, tab1, tab2] -> [tab0, tab2, tab1] -> [tab2, tab1, tab0] #`);
+  info(`start media for tab1, main controller should become tab1`);
+  await makeTabBecomeMainController(tab1);
+
+  info(`currrent metadata should be equal to tab1's metadata`);
+  await isCurrentMetadataEqualTo(tab1.metadata);
+
+  info(`start media for tab0, main controller should become tab0`);
+  await makeTabBecomeMainController(tab0);
+
+  info(`currrent metadata should be equal to tab0's metadata`);
+  await isCurrentMetadataEqualTo(tab0.metadata);
+
+  /**
+   * part3 : [tab2, tab1, tab0] -> [tab2, tab1] -> [tab2] -> []
+   */
+  info(`# [tab2, tab1, tab0] -> [tab2, tab1] -> [tab2] -> [] #`);
+  info(`remove tab0 and wait until main controller changes`);
+  await Promise.all([waitUntilMainMediaControllerChanged(), tab0.close()]);
+
+  info(`currrent metadata should be equal to tab1's metadata`);
+  await isCurrentMetadataEqualTo(tab1.metadata);
+
+  info(`remove tab1 and wait until main controller changes`);
+  await Promise.all([waitUntilMainMediaControllerChanged(), tab1.close()]);
+
+  info(`currrent metadata should be equal to tab2's metadata`);
+  await isCurrentMetadataEqualTo(tab2.metadata);
+
+  info(`remove tab2 and wait until main controller changes`);
+  await Promise.all([waitUntilMainMediaControllerChanged(), tab2.close()]);
+  isCurrentMetadataEmpty();
+});
+
+add_task(async function testPIPControllerWontBeReplacedByNormalController() {
+  info(`open two different tabs`);
+  const tab0 = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY);
+  const tab1 = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY);
+
+  info(`set different metadata for each tab`);
+  await setMediaMetadataForTabs([tab0, tab1]);
+
+  info(`start media for tab0, main controller should become tab0`);
+  await makeTabBecomeMainControllerAndWaitForMetadataChange(tab0);
+
+  info(`currrent metadata should be equal to tab0's metadata`);
+  await isCurrentMetadataEqualTo(tab0.metadata);
+
+  info(`trigger Picture-in-Picture mode for tab0`);
+  const winPIP = await triggerPictureInPicture(tab0.linkedBrowser, testVideoId);
+
+  info(`start media for tab1, main controller should still be tab0`);
+  await playMediaAndWaitUntilRegisteringController(tab1, testVideoId);
+
+  info(`currrent metadata should be equal to tab0's metadata`);
+  await isCurrentMetadataEqualTo(tab0.metadata);
+
+  info(`remove tab0 and wait until main controller changes`);
+  await BrowserTestUtils.closeWindow(winPIP);
+  await Promise.all([waitUntilMainMediaControllerChanged(), tab0.close()]);
+
+  info(`currrent metadata should be equal to tab1's metadata`);
+  await isCurrentMetadataEqualTo(tab1.metadata);
+
+  info(`remove tab1 and wait until main controller changes`);
+  await Promise.all([waitUntilMainMediaControllerChanged(), tab1.close()]);
+  isCurrentMetadataEmpty();
+});
+
+add_task(
+  async function testFullscreenControllerWontBeReplacedByNormalController() {
+    info(`open two different tabs`);
+    const tab0 = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY);
+    const tab1 = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY);
+
+    info(`set different metadata for each tab`);
+    await setMediaMetadataForTabs([tab0, tab1]);
+
+    info(`start media for tab0, main controller should become tab0`);
+    await makeTabBecomeMainControllerAndWaitForMetadataChange(tab0);
+
+    info(`current metadata should be equal to tab0's metadata`);
+    await isCurrentMetadataEqualTo(tab0.metadata);
+
+    info(`video in tab0 enters fullscreen`);
+    await switchTabToForegroundAndEnableFullScreen(tab0, testVideoId);
+
+    info(
+      `normal controller won't become the main controller, ` +
+        `which is still fullscreen controller`
+    );
+    await playMediaAndWaitUntilRegisteringController(tab1, testVideoId);
+
+    info(`currrent metadata should be equal to tab0's metadata`);
+    await isCurrentMetadataEqualTo(tab0.metadata);
+
+    info(`remove tabs`);
+    await Promise.all([tab0.close(), tab1.close()]);
+  }
+);
+
+add_task(async function testFullscreenAndPIPControllers() {
+  info(`open three different tabs`);
+  const tab0 = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY);
+  const tab1 = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY);
+  const tab2 = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY);
+
+  info(`set different metadata for each tab`);
+  await setMediaMetadataForTabs([tab0, tab1, tab2]);
+
+  /**
+   * Current controller list : [tab0 (fullscreen)]
+   */
+  info(`start media for tab0, main controller should become tab0`);
+  await makeTabBecomeMainControllerAndWaitForMetadataChange(tab0);
+
+  info(`currrent metadata should be equal to tab0's metadata`);
+  await isCurrentMetadataEqualTo(tab0.metadata);
+
+  info(`video in tab0 enters fullscreen`);
+  await switchTabToForegroundAndEnableFullScreen(tab0, testVideoId);
+
+  /**
+   * Current controller list : [tab1, tab0 (fullscreen)]
+   */
+  info(`start media for tab1, main controller should still be tab0`);
+  await playMediaAndWaitUntilRegisteringController(tab1, testVideoId);
+
+  info(`currrent metadata should be equal to tab0's metadata`);
+  await isCurrentMetadataEqualTo(tab0.metadata);
+
+  /**
+   * Current controller list : [tab0 (fullscreen), tab1 (PIP)]
+   */
+  info(`tab1 enters PIP so tab1 should become new main controller`);
+  const mainControllerChange = waitUntilMainMediaControllerChanged();
+  const winPIP = await triggerPictureInPicture(tab1.linkedBrowser, testVideoId);
+  await mainControllerChange;
+
+  info(`currrent metadata should be equal to tab1's metadata`);
+  await isCurrentMetadataEqualTo(tab1.metadata);
+
+  /**
+   * Current controller list : [tab2, tab0 (fullscreen), tab1 (PIP)]
+   */
+  info(`play video from tab2 which shouldn't affect main controller`);
+  await playMediaAndWaitUntilRegisteringController(tab2, testVideoId);
+
+  /**
+   * Current controller list : [tab2, tab0 (fullscreen)]
+   */
+  info(`remove tab1 and wait until main controller changes`);
+  await BrowserTestUtils.closeWindow(winPIP);
+  await Promise.all([waitUntilMainMediaControllerChanged(), tab1.close()]);
+
+  info(`currrent metadata should be equal to tab0's metadata`);
+  await isCurrentMetadataEqualTo(tab0.metadata);
+
+  /**
+   * Current controller list : [tab2]
+   */
+  info(`remove tab0 and wait until main controller changes`);
+  await Promise.all([waitUntilMainMediaControllerChanged(), tab0.close()]);
+
+  info(`currrent metadata should be equal to tab0's metadata`);
+  await isCurrentMetadataEqualTo(tab2.metadata);
+
+  /**
+   * Current controller list : []
+   */
+  info(`remove tab2 and wait until main controller changes`);
+  await Promise.all([waitUntilMainMediaControllerChanged(), tab2.close()]);
+  isCurrentMetadataEmpty();
+});
+
+/**
+ * The following are helper functions
+ */
+async function setMediaMetadataForTabs(tabs) {
+  for (let idx = 0; idx < tabs.length; idx++) {
+    const tabName = "tab" + idx;
+    info(`create metadata for ${tabName}`);
+    tabs[idx].metadata = {
+      title: tabName,
+      artist: tabName,
+      album: tabName,
+      artwork: [{ src: tabName, sizes: "128x128", type: "image/jpeg" }],
+    };
+    const spawn = SpecialPowers.spawn(
+      tabs[idx].linkedBrowser,
+      [tabs[idx].metadata],
+      data => {
+        content.navigator.mediaSession.metadata = new content.MediaMetadata(
+          data
+        );
+      }
+    );
+    // As those controller hasn't been activated yet, we can't listen to
+    // `mediacontroll.onmetadatachange`, which would only be notified after a
+    // controller becomes active.
+    await Promise.all([spawn, waitUntilControllerMetadataChanged()]);
+  }
+}
+
+function makeTabBecomeMainController(tab) {
+  const playPromise = SpecialPowers.spawn(
+    tab.linkedBrowser,
+    [testVideoId],
+    async Id => {
+      const video = content.document.getElementById(Id);
+      if (!video) {
+        ok(false, `can't get the media element!`);
+      }
+      // If media has been started, we would stop media first and then start it
+      // again, which would make controller's playback state change to `playing`
+      // again and result in updating new main controller.
+      if (!video.paused) {
+        video.pause();
+        info(`wait until media stops`);
+        await new Promise(r => (video.onpause = r));
+      }
+      info(`start media`);
+      return video.play();
+    }
+  );
+  return Promise.all([playPromise, waitUntilMainMediaControllerChanged()]);
+}
+
+function makeTabBecomeMainControllerAndWaitForMetadataChange(tab) {
+  return Promise.all([
+    new Promise(r => (tab.controller.onmetadatachange = r)),
+    makeTabBecomeMainController(tab),
+  ]);
+}
+
+function playMediaAndWaitUntilRegisteringController(tab, elementId) {
+  const playPromise = SpecialPowers.spawn(
+    tab.linkedBrowser,
+    [elementId],
+    Id => {
+      const video = content.document.getElementById(Id);
+      if (!video) {
+        ok(false, `can't get the media element!`);
+      }
+      return video.play();
+    }
+  );
+  return Promise.all([waitUntilMediaControllerAmountChanged(), playPromise]);
+}
+
+async function switchTabToForegroundAndEnableFullScreen(tab, elementId) {
+  // Fullscreen can only be allowed to enter from a focus tab.
+  await BrowserTestUtils.switchTab(gBrowser, tab.tabElement);
+  await SpecialPowers.spawn(tab.linkedBrowser, [elementId], elementId => {
+    return new Promise(r => {
+      const element = content.document.getElementById(elementId);
+      element.requestFullscreen();
+      element.onfullscreenchange = () => {
+        element.onfullscreenchange = null;
+        element.onfullscreenerror = null;
+        r();
+      };
+      element.onfullscreenerror = () => {
+        // Retry until the element successfully enters fullscreen.
+        element.requestFullscreen();
+      };
+    });
+  });
+}
diff --git a/dom/media/mediacontrol/tests/browser/browser_media_control_metadata.js b/dom/media/mediacontrol/tests/browser/browser_media_control_metadata.js
new file mode 100644
index 0000000000..75a0d80ac9
--- /dev/null
+++ b/dom/media/mediacontrol/tests/browser/browser_media_control_metadata.js
@@ -0,0 +1,416 @@
+const PAGE_NON_AUTOPLAY =
+  "https://example.com/browser/dom/media/mediacontrol/tests/browser/file_non_autoplay.html";
+const PAGE_EMPTY_TITLE_URL =
+  "https://example.com/browser/dom/media/mediacontrol/tests/browser/file_empty_title.html";
+
+const testVideoId = "video";
+const defaultFaviconName = "defaultFavicon.svg";
+
+add_task(async function setupTestingPref() {
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      ["media.mediacontrol.testingevents.enabled", true],
+      ["dom.media.mediasession.enabled", true],
+    ],
+  });
+});
+
+/**
+ * This test includes many different test cases of checking the current media
+ * metadata from the tab which is being controlled by the media control. Each
+ * `add_task(..)` is a different testing scenario.
+ *
+ * Media metadata is the information that can tell user about what title, artist,
+ * album and even art work the tab is currently playing to. The metadta is
+ * usually set from MediaSession API, but if the site doesn't use that API, we
+ * would also generate a default metadata instead.
+ *
+ * The current metadata would only be available after the page starts playing
+ * media at least once, if the page hasn't started any media before, then the
+ * current metadata is always empty.
+ *
+ * For following situations, we would create a default metadata which title is
+ * website's title and artwork is from our default favicon icon.
+ * (1) the page doesn't use MediaSession API
+ * (2) media session doesn't has metadata
+ * (3) media session has an empty metadata
+ *
+ * Otherwise, the current metadata would be media session's metadata from the
+ * tab which is currently controlled by the media control.
+ */
+add_task(async function testDefaultMetadataForPageWithoutMediaSession() {
+  info(`open media page`);
+  const tab = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY);
+
+  info(`start media`);
+  await playMedia(tab, testVideoId);
+
+  info(`should use default metadata because of lacking of media session`);
+  await isGivenTabUsingDefaultMetadata(tab);
+
+  info(`remove tab`);
+  await tab.close();
+});
+
+add_task(
+  async function testDefaultMetadataForEmptyTitlePageWithoutMediaSession() {
+    info(`open media page`);
+    const tab = await createLoadedTabWrapper(PAGE_EMPTY_TITLE_URL);
+
+    info(`start media`);
+    await playMedia(tab, testVideoId);
+
+    info(`should use default metadata because of lacking of media session`);
+    await isGivenTabUsingDefaultMetadata(tab);
+
+    info(`remove tab`);
+    await tab.close();
+  }
+);
+
+add_task(async function testDefaultMetadataForPageUsingEmptyMetadata() {
+  info(`open media page`);
+  const tab = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY);
+
+  info(`start media`);
+  await playMedia(tab, testVideoId);
+
+  info(`create empty media metadata`);
+  await setMediaMetadata(tab, {
+    title: "",
+    artist: "",
+    album: "",
+    artwork: [],
+  });
+
+  info(`should use default metadata because of empty media metadata`);
+  await isGivenTabUsingDefaultMetadata(tab);
+
+  info(`remove tab`);
+  await tab.close();
+});
+
+add_task(async function testDefaultMetadataForPageUsingNullMetadata() {
+  info(`open media page`);
+  const tab = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY);
+
+  info(`start media`);
+  await playMedia(tab, testVideoId);
+
+  info(`create empty media metadata`);
+  await setNullMediaMetadata(tab);
+
+  info(`should use default metadata because of lacking of media metadata`);
+  await isGivenTabUsingDefaultMetadata(tab);
+
+  info(`remove tab`);
+  await tab.close();
+});
+
+add_task(async function testMetadataWithEmptyTitleAndArtwork() {
+  info(`open media page`);
+  const tab = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY);
+
+  info(`start media`);
+  await playMedia(tab, testVideoId);
+
+  info(`create media metadata with empty title and artwork`);
+  await setMediaMetadata(tab, {
+    title: "",
+    artist: "foo",
+    album: "bar",
+    artwork: [],
+  });
+
+  info(`should use default metadata because of empty title and artwork`);
+  await isGivenTabUsingDefaultMetadata(tab);
+
+  info(`remove tab`);
+  await tab.close();
+});
+
+add_task(async function testMetadataWithoutTitleAndArtwork() {
+  info(`open media page`);
+  const tab = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY);
+
+  info(`start media`);
+  await playMedia(tab, testVideoId);
+
+  info(`create media metadata with empty title and artwork`);
+  await setMediaMetadata(tab, {
+    artist: "foo",
+    album: "bar",
+  });
+
+  info(`should use default metadata because of lacking of title and artwork`);
+  await isGivenTabUsingDefaultMetadata(tab);
+
+  info(`remove tab`);
+  await tab.close();
+});
+
+add_task(async function testMetadataInPrivateBrowsing() {
+  info(`create a private window`);
+  const inputWindow = await BrowserTestUtils.openNewBrowserWindow({
+    private: true,
+  });
+
+  info(`open media page`);
+  const tab = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY, { inputWindow });
+
+  info(`start media`);
+  await playMedia(tab, testVideoId);
+
+  info(`set metadata`);
+  let metadata = {
+    title: "foo",
+    artist: "bar",
+    album: "foo",
+    artwork: [{ src: "bar.jpg", sizes: "128x128", type: "image/jpeg" }],
+  };
+  await setMediaMetadata(tab, metadata);
+
+  info(`should use default metadata because of in private browsing mode`);
+  await isGivenTabUsingDefaultMetadata(tab, { isPrivateBrowsing: true });
+
+  info(`remove tab`);
+  await tab.close();
+
+  info(`close private window`);
+  await BrowserTestUtils.closeWindow(inputWindow);
+});
+
+add_task(async function testSetMetadataFromMediaSessionAPI() {
+  info(`open media page`);
+  const tab = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY);
+
+  info(`start media`);
+  await playMedia(tab, testVideoId);
+
+  info(`set metadata`);
+  let metadata = {
+    title: "foo",
+    artist: "bar",
+    album: "foo",
+    artwork: [{ src: "bar.jpg", sizes: "128x128", type: "image/jpeg" }],
+  };
+  await setMediaMetadata(tab, metadata);
+
+  info(`check if current active metadata is equal to what we've set before`);
+  await isCurrentMetadataEqualTo(metadata);
+
+  info(`set metadata again to see if current metadata would change`);
+  metadata = {
+    title: "foo2",
+    artist: "bar2",
+    album: "foo2",
+    artwork: [{ src: "bar2.jpg", sizes: "129x129", type: "image/jpeg" }],
+  };
+  await setMediaMetadata(tab, metadata);
+
+  info(`check if current active metadata is equal to what we've set before`);
+  await isCurrentMetadataEqualTo(metadata);
+
+  info(`remove tab`);
+  await tab.close();
+});
+
+add_task(async function testSetMetadataBeforeMediaStarts() {
+  info(`open media page`);
+  const tab = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY, {
+    needCheck: false,
+  });
+
+  info(`set metadata`);
+  let metadata = {
+    title: "foo",
+    artist: "bar",
+    album: "foo",
+    artwork: [{ src: "bar.jpg", sizes: "128x128", type: "image/jpeg" }],
+  };
+  await setMediaMetadata(tab, metadata, { notExpectChange: true });
+
+  info(`current media metadata should be empty before media starts`);
+  isCurrentMetadataEmpty();
+
+  info(`remove tab`);
+  await tab.close();
+});
+
+add_task(async function testSetMetadataAfterMediaPaused() {
+  info(`open media page`);
+  const tab = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY);
+
+  info(`start media in order to let this tab be controlled`);
+  await playMedia(tab, testVideoId);
+
+  info(`pause media`);
+  await pauseMedia(tab, testVideoId);
+
+  info(`set metadata after media is paused`);
+  let metadata = {
+    title: "foo",
+    artist: "bar",
+    album: "foo",
+    artwork: [{ src: "bar.jpg", sizes: "128x128", type: "image/jpeg" }],
+  };
+  await setMediaMetadata(tab, metadata);
+
+  info(`check if current active metadata is equal to what we've set before`);
+  await isCurrentMetadataEqualTo(metadata);
+
+  info(`remove tab`);
+  await tab.close();
+});
+
+add_task(async function testSetMetadataAmongMultipleTabs() {
+  info(`open media page in tab1`);
+  const tab1 = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY);
+
+  info(`start media in tab1`);
+  await playMedia(tab1, testVideoId);
+
+  info(`set metadata for tab1`);
+  let metadata = {
+    title: "foo",
+    artist: "bar",
+    album: "foo",
+    artwork: [{ src: "bar.jpg", sizes: "128x128", type: "image/jpeg" }],
+  };
+  await setMediaMetadata(tab1, metadata);
+
+  info(`check if current active metadata is equal to what we've set before`);
+  await isCurrentMetadataEqualTo(metadata);
+
+  info(`open another page in tab2`);
+  const tab2 = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY);
+
+  info(`start media in tab2`);
+  await playMedia(tab2, testVideoId);
+
+  info(`set metadata for tab2`);
+  metadata = {
+    title: "foo2",
+    artist: "bar2",
+    album: "foo2",
+    artwork: [{ src: "bar2.jpg", sizes: "129x129", type: "image/jpeg" }],
+  };
+  await setMediaMetadata(tab2, metadata);
+
+  info(`current active metadata should become metadata from tab2`);
+  await isCurrentMetadataEqualTo(metadata);
+
+  info(
+    `update metadata for tab1, which should not affect current metadata ` +
+      `because media session in tab2 is the one we're controlling right now`
+  );
+  await setMediaMetadata(tab1, {
+    title: "foo3",
+    artist: "bar3",
+    album: "foo3",
+    artwork: [{ src: "bar3.jpg", sizes: "130x130", type: "image/jpeg" }],
+  });
+
+  info(`current active metadata should still be metadata from tab2`);
+  await isCurrentMetadataEqualTo(metadata);
+
+  info(`remove tabs`);
+  await Promise.all([tab1.close(), tab2.close()]);
+});
+
+add_task(async function testMetadataAfterTabNavigation() {
+  info(`open media page`);
+  const tab = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY);
+
+  info(`start media`);
+  await playMedia(tab, testVideoId);
+
+  info(`set metadata`);
+  let metadata = {
+    title: "foo",
+    artist: "bar",
+    album: "foo",
+    artwork: [{ src: "bar.jpg", sizes: "128x128", type: "image/jpeg" }],
+  };
+  await setMediaMetadata(tab, metadata);
+
+  info(`check if current active metadata is equal to what we've set before`);
+  await isCurrentMetadataEqualTo(metadata);
+
+  info(`navigate tab to blank page`);
+  await Promise.all([
+    new Promise(r => (tab.controller.ondeactivated = r)),
+    BrowserTestUtils.loadURIString(tab.linkedBrowser, "about:blank"),
+  ]);
+
+  info(`current media metadata should be reset`);
+  isCurrentMetadataEmpty();
+
+  info(`remove tab`);
+  await tab.close();
+});
+
+add_task(async function testUpdateDefaultMetadataWhenPageTitleChanges() {
+  info(`open media page`);
+  const tab = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY);
+
+  info(`start media`);
+  await playMedia(tab, testVideoId);
+
+  info(`should use default metadata because of lacking of media session`);
+  await isGivenTabUsingDefaultMetadata(tab);
+
+  info(`default metadata should be updated after page title changes`);
+  await changePageTitle(tab, { shouldAffectMetadata: true });
+  await isGivenTabUsingDefaultMetadata(tab);
+
+  info(`after setting metadata, title change won't affect current metadata`);
+  const metadata = {
+    title: "foo",
+    artist: "bar",
+    album: "foo",
+    artwork: [{ src: "bar.jpg", sizes: "128x128", type: "image/jpeg" }],
+  };
+  await setMediaMetadata(tab, metadata);
+  await changePageTitle(tab, { shouldAffectMetadata: false });
+  await isCurrentMetadataEqualTo(metadata);
+
+  info(`remove tab`);
+  await tab.close();
+});
+
+/**
+ * The following are helper functions.
+ */
+function setMediaMetadata(tab, metadata, { notExpectChange } = {}) {
+  const controller = tab.linkedBrowser.browsingContext.mediaController;
+  const metadatachangePromise = notExpectChange
+    ? Promise.resolve()
+    : new Promise(r => (controller.onmetadatachange = r));
+  return Promise.all([
+    metadatachangePromise,
+    SpecialPowers.spawn(tab.linkedBrowser, [metadata], data => {
+      content.navigator.mediaSession.metadata = new content.MediaMetadata(data);
+    }),
+  ]);
+}
+
+function setNullMediaMetadata(tab) {
+  const promise = SpecialPowers.spawn(tab.linkedBrowser, [], () => {
+    content.navigator.mediaSession.metadata = null;
+  });
+  return Promise.all([promise, waitUntilControllerMetadataChanged()]);
+}
+
+async function changePageTitle(tab, { shouldAffectMetadata } = {}) {
+  const controller = tab.linkedBrowser.browsingContext.mediaController;
+  const shouldWaitMetadataChangePromise = shouldAffectMetadata
+    ? new Promise(r => (controller.onmetadatachange = r))
+    : Promise.resolve();
+  await Promise.all([
+    shouldWaitMetadataChangePromise,
+    SpecialPowers.spawn(tab.linkedBrowser, [], _ => {
+      content.document.title = "new title";
+    }),
+  ]);
+}
diff --git a/dom/media/mediacontrol/tests/browser/browser_media_control_non_eligible_media.js b/dom/media/mediacontrol/tests/browser/browser_media_control_non_eligible_media.js
new file mode 100644
index 0000000000..ab18eab634
--- /dev/null
+++ b/dom/media/mediacontrol/tests/browser/browser_media_control_non_eligible_media.js
@@ -0,0 +1,204 @@
+const PAGE_NON_ELIGIBLE_MEDIA =
+  "https://example.com/browser/dom/media/mediacontrol/tests/browser/file_non_eligible_media.html";
+
+// Import this in order to use `triggerPictureInPicture()`.
+Services.scriptloader.loadSubScript(
+  "chrome://mochitests/content/browser/toolkit/components/pictureinpicture/tests/head.js",
+  this
+);
+
+// Bug 1673509 - This test requests a lot of fullscreen for media elements,
+// which sometime Gecko would take longer time to fulfill.
+requestLongerTimeout(2);
+
+// This array contains the elements' id in `file_non_eligible_media.html`.
+const gNonEligibleElementIds = [
+  "muted",
+  "volume-0",
+  "silent-audio-track",
+  "no-audio-track",
+  "short-duration",
+  "inaudible-captured-media",
+];
+
+/**
+ * This test is used to test couples of things about what kinds of media is
+ * eligible for being controlled by media control keys.
+ * (1) If media is inaudible all the time, then we would not control it.
+ * (2) If media starts inaudibly, we would not try to control it. But once it
+ * becomes audible later, we would keep controlling it until it's destroyed.
+ * (3) If media's duration is too short (<3s), then we would not control it.
+ */
+add_task(async function setupTestingPref() {
+  await SpecialPowers.pushPrefEnv({
+    set: [["media.mediacontrol.testingevents.enabled", true]],
+  });
+});
+
+add_task(
+  async function testNonAudibleMediaCantActivateControllerButAudibleMediaCan() {
+    for (const elementId of gNonEligibleElementIds) {
+      info(`open new tab with non eligible media elements`);
+      const tab = await createLoadedTabWrapper(PAGE_NON_ELIGIBLE_MEDIA, {
+        needCheck: couldElementBecomeEligible(elementId),
+      });
+
+      info(`although media is playing but it won't activate controller`);
+      await Promise.all([
+        startNonEligibleMedia(tab, elementId),
+        checkIfMediaIsStillPlaying(tab, elementId),
+      ]);
+      ok(!tab.controller.isActive, "controller is still inactive");
+
+      if (couldElementBecomeEligible(elementId)) {
+        info(`make element ${elementId} audible would activate controller`);
+        await Promise.all([
+          makeElementEligible(tab, elementId),
+          checkOrWaitUntilControllerBecomeActive(tab),
+        ]);
+      }
+
+      info(`remove tab`);
+      await tab.close();
+    }
+  }
+);
+
+/**
+ * Normally those media are not able to being controlled, however, once they
+ * enter fullsceen or Picture-in-Picture mode, then they can be controlled.
+ */
+add_task(async function testNonEligibleMediaEnterFullscreen() {
+  info(`open new tab with non eligible media elements`);
+  const tab = await createLoadedTabWrapper(PAGE_NON_ELIGIBLE_MEDIA);
+
+  for (const elementId of gNonEligibleElementIds) {
+    await startNonEligibleMedia(tab, elementId);
+
+    info(`entering fullscreen should activate the media controller`);
+    await enterFullScreen(tab, elementId);
+    await checkOrWaitUntilControllerBecomeActive(tab);
+    ok(true, `fullscreen ${elementId} media is able to being controlled`);
+
+    info(`leave fullscreen`);
+    await leaveFullScreen(tab);
+  }
+  info(`remove tab`);
+  await tab.close();
+});
+
+add_task(async function testNonEligibleMediaEnterPIPMode() {
+  info(`open new tab with non eligible media elements`);
+  const tab = await createLoadedTabWrapper(PAGE_NON_ELIGIBLE_MEDIA);
+
+  for (const elementId of gNonEligibleElementIds) {
+    await startNonEligibleMedia(tab, elementId);
+
+    info(`media entering PIP mode should activate the media controller`);
+    const winPIP = await triggerPictureInPicture(tab.linkedBrowser, elementId);
+    await checkOrWaitUntilControllerBecomeActive(tab);
+    ok(true, `PIP ${elementId} media is able to being controlled`);
+
+    info(`stop PIP mode`);
+    await BrowserTestUtils.closeWindow(winPIP);
+  }
+  info(`remove tab`);
+  await tab.close();
+});
+
+/**
+ * The following are helper functions.
+ */
+function startNonEligibleMedia(tab, elementId) {
+  return SpecialPowers.spawn(tab.linkedBrowser, [elementId], Id => {
+    const video = content.document.getElementById(Id);
+    if (!video) {
+      ok(false, `can't get the media element!`);
+    }
+    if (Id == "volume-0") {
+      video.volume = 0.0;
+    }
+    if (Id == "inaudible-captured-media") {
+      const context = new content.AudioContext();
+      context.createMediaElementSource(video);
+    }
+    info(`start non eligible media ${Id}`);
+    return video.play();
+  });
+}
+
+function checkIfMediaIsStillPlaying(tab, elementId) {
+  return SpecialPowers.spawn(tab.linkedBrowser, [elementId], Id => {
+    const video = content.document.getElementById(Id);
+    if (!video) {
+      ok(false, `can't get the media element!`);
+    }
+    return new Promise(r => {
+      // In order to test "media isn't affected by media control", we would not
+      // only check `mPaused`, we would also oberve "timeupdate" event multiple
+      // times to ensure that video is still playing continually.
+      let timeUpdateCount = 0;
+      ok(!video.paused);
+      video.ontimeupdate = () => {
+        if (++timeUpdateCount == 3) {
+          video.ontimeupdate = null;
+          r();
+        }
+      };
+    });
+  });
+}
+
+function couldElementBecomeEligible(elementId) {
+  return elementId == "muted" || elementId == "volume-0";
+}
+
+function makeElementEligible(tab, elementId) {
+  return SpecialPowers.spawn(tab.linkedBrowser, [elementId], Id => {
+    const video = content.document.getElementById(Id);
+    if (!video) {
+      ok(false, `can't get the media element!`);
+    }
+    // to turn inaudible media become audible in order to be controlled.
+    video.volume = 1.0;
+    video.muted = false;
+  });
+}
+
+function waitUntilMediaPaused(tab, elementId) {
+  return SpecialPowers.spawn(tab.linkedBrowser, [elementId], Id => {
+    const video = content.document.getElementById(Id);
+    if (!video) {
+      ok(false, `can't get the media element!`);
+    }
+    if (video.paused) {
+      ok(true, "media has been paused");
+      return Promise.resolve();
+    }
+    return new Promise(r => (video.onpaused = r));
+  });
+}
+
+function enterFullScreen(tab, elementId) {
+  return SpecialPowers.spawn(tab.linkedBrowser, [elementId], Id => {
+    return new Promise(r => {
+      const element = content.document.getElementById(Id);
+      element.requestFullscreen();
+      element.onfullscreenchange = () => {
+        element.onfullscreenchange = null;
+        element.onfullscreenerror = null;
+        r();
+      };
+      element.onfullscreenerror = () => {
+        // Retry until the element successfully enters fullscreen.
+        element.requestFullscreen();
+      };
+    });
+  });
+}
+
+function leaveFullScreen(tab) {
+  return SpecialPowers.spawn(tab.linkedBrowser, [], _ => {
+    return content.document.exitFullscreen();
+  });
+}
diff --git a/dom/media/mediacontrol/tests/browser/browser_media_control_playback_state.js b/dom/media/mediacontrol/tests/browser/browser_media_control_playback_state.js
new file mode 100644
index 0000000000..4d30566e0a
--- /dev/null
+++ b/dom/media/mediacontrol/tests/browser/browser_media_control_playback_state.js
@@ -0,0 +1,116 @@
+const PAGE_NON_AUTOPLAY =
+  "https://example.com/browser/dom/media/mediacontrol/tests/browser/file_non_autoplay.html";
+
+const testVideoId = "video";
+
+add_task(async function setupTestingPref() {
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      ["media.mediacontrol.testingevents.enabled", true],
+      ["dom.media.mediasession.enabled", true],
+    ],
+  });
+});
+
+/**
+ * This test is used to check the actual playback state [1] of the main media
+ * controller. The declared playback state is the playback state from the active
+ * media session, and the guessed playback state is determined by the media's
+ * playback state. Both the declared playback and the guessed playback state
+ * would be used to decide the final result of the actual playback state.
+ *
+ * [1] https://w3c.github.io/mediasession/#actual-playback-state
+ */
+add_task(async function testDefaultPlaybackStateBeforeAnyMediaStart() {
+  info(`open media page`);
+  const tab = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY, {
+    needCheck: false,
+  });
+
+  info(`before media starts, playback state should be 'none'`);
+  await isActualPlaybackStateEqualTo(tab, "none");
+
+  info(`remove tab`);
+  await tab.close();
+});
+
+add_task(async function testGuessedPlaybackState() {
+  info(`open media page`);
+  const tab = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY);
+
+  info(
+    `Now declared='none', guessed='playing', so actual playback state should be 'playing'`
+  );
+  await setGuessedPlaybackState(tab, "playing");
+  await isActualPlaybackStateEqualTo(tab, "playing");
+
+  info(
+    `Now declared='none', guessed='paused', so actual playback state should be 'paused'`
+  );
+  await setGuessedPlaybackState(tab, "paused");
+  await isActualPlaybackStateEqualTo(tab, "paused");
+
+  info(`remove tab`);
+  await tab.close();
+});
+
+add_task(async function testBothGuessedAndDeclaredPlaybackState() {
+  info(`open media page`);
+  const tab = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY);
+
+  info(
+    `Now declared='paused', guessed='playing', so actual playback state should be 'playing'`
+  );
+  await setDeclaredPlaybackState(tab, "paused");
+  await setGuessedPlaybackState(tab, "playing");
+  await isActualPlaybackStateEqualTo(tab, "playing");
+
+  info(
+    `Now declared='paused', guessed='paused', so actual playback state should be 'paused'`
+  );
+  await setGuessedPlaybackState(tab, "paused");
+  await isActualPlaybackStateEqualTo(tab, "paused");
+
+  info(
+    `Now declared='playing', guessed='paused', so actual playback state should be 'playing'`
+  );
+  await setDeclaredPlaybackState(tab, "playing");
+  await isActualPlaybackStateEqualTo(tab, "playing");
+
+  info(`remove tab`);
+  await tab.close();
+});
+
+/**
+ * The following are helper functions.
+ */
+function setGuessedPlaybackState(tab, state) {
+  if (state == "playing") {
+    return playMedia(tab, testVideoId);
+  } else if (state == "paused") {
+    return pauseMedia(tab, testVideoId);
+  }
+  // We won't set the state `stopped`, which would only happen if no any media
+  // has ever been started in the page.
+  ok(false, `should only set 'playing' or 'paused' state`);
+  return Promise.resolve();
+}
+
+async function isActualPlaybackStateEqualTo(tab, expectedState) {
+  const controller = tab.linkedBrowser.browsingContext.mediaController;
+  if (controller.playbackState != expectedState) {
+    await new Promise(r => (controller.onplaybackstatechange = r));
+  }
+  is(
+    controller.playbackState,
+    expectedState,
+    `current state '${controller.playbackState}' is equal to '${expectedState}'`
+  );
+}
+
+function setDeclaredPlaybackState(tab, state) {
+  return SpecialPowers.spawn(tab.linkedBrowser, [state], playbackState => {
+    info(`set declared playback state to '${playbackState}'`);
+    content.navigator.mediaSession.playbackState = playbackState;
+  });
+}
diff --git a/dom/media/mediacontrol/tests/browser/browser_media_control_position_state.js b/dom/media/mediacontrol/tests/browser/browser_media_control_position_state.js
new file mode 100644
index 0000000000..f32ce26063
--- /dev/null
+++ b/dom/media/mediacontrol/tests/browser/browser_media_control_position_state.js
@@ -0,0 +1,150 @@
+const PAGE_URL =
+  "https://example.com/browser/dom/media/mediacontrol/tests/browser/file_non_autoplay.html";
+const IFRAME_URL =
+  "https://example.com/browser/dom/media/mediacontrol/tests/browser/file_iframe_media.html";
+
+const testVideoId = "video";
+
+add_task(async function setupTestingPref() {
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      ["media.mediacontrol.testingevents.enabled", true],
+      ["dom.media.mediasession.enabled", true],
+    ],
+  });
+});
+
+/**
+ * This test is used to check if we can receive correct position state change,
+ * when we set the position state to the media session.
+ */
+add_task(async function testSetPositionState() {
+  info(`open media page`);
+  const tab = await createLoadedTabWrapper(PAGE_URL);
+
+  info(`start media`);
+  await playMedia(tab, testVideoId);
+
+  info(`set duration only`);
+  await setPositionState(tab, {
+    duration: 60,
+  });
+
+  info(`set duration and playback rate`);
+  await setPositionState(tab, {
+    duration: 50,
+    playbackRate: 2.0,
+  });
+
+  info(`set duration, playback rate and position`);
+  await setPositionState(tab, {
+    duration: 40,
+    playbackRate: 3.0,
+    position: 10,
+  });
+
+  info(`remove tab`);
+  await tab.close();
+});
+
+add_task(async function testSetPositionStateFromInactiveMediaSession() {
+  info(`open media page`);
+  const tab = await createLoadedTabWrapper(PAGE_URL);
+
+  info(`start media`);
+  await playMedia(tab, testVideoId);
+
+  info(
+    `add an event listener to measure how many times the position state changes`
+  );
+  let positionChangedNum = 0;
+  const controller = tab.linkedBrowser.browsingContext.mediaController;
+  controller.onpositionstatechange = () => positionChangedNum++;
+
+  info(`set position state on the main page which has an active media session`);
+  await setPositionState(tab, {
+    duration: 60,
+  });
+
+  info(`set position state on the iframe which has an inactive media session`);
+  await setPositionStateOnInactiveMediaSession(tab);
+
+  info(`set position state on the main page again`);
+  await setPositionState(tab, {
+    duration: 60,
+  });
+  is(
+    positionChangedNum,
+    2,
+    `We should only receive two times of position change, because ` +
+      `the second one which performs on inactive media session is effectless`
+  );
+
+  info(`remove tab`);
+  await tab.close();
+});
+
+/**
+ * The following are helper functions.
+ */
+async function setPositionState(tab, positionState) {
+  const controller = tab.linkedBrowser.browsingContext.mediaController;
+  const positionStateChanged = new Promise(r => {
+    controller.addEventListener(
+      "positionstatechange",
+      event => {
+        const { duration, playbackRate, position } = positionState;
+        // duration is mandatory.
+        is(
+          event.duration,
+          duration,
+          `expected duration ${event.duration} is equal to ${duration}`
+        );
+
+        // Playback rate is optional, if it's not present, default should be 1.0
+        if (playbackRate) {
+          is(
+            event.playbackRate,
+            playbackRate,
+            `expected playbackRate ${event.playbackRate} is equal to ${playbackRate}`
+          );
+        } else {
+          is(event.playbackRate, 1.0, `expected default playbackRate is 1.0`);
+        }
+
+        // Position state is optional, if it's not present, default should be 0.0
+        if (position) {
+          is(
+            event.position,
+            position,
+            `expected position ${event.position} is equal to ${position}`
+          );
+        } else {
+          is(event.position, 0.0, `expected default position is 0.0`);
+        }
+        r();
+      },
+      { once: true }
+    );
+  });
+  await SpecialPowers.spawn(
+    tab.linkedBrowser,
+    [positionState],
+    positionState => {
+      content.navigator.mediaSession.setPositionState(positionState);
+    }
+  );
+  await positionStateChanged;
+}
+
+async function setPositionStateOnInactiveMediaSession(tab) {
+  return SpecialPowers.spawn(tab.linkedBrowser, [IFRAME_URL], async url => {
+    info(`create iframe and wait until it finishes loading`);
+    const iframe = content.document.getElementById("iframe");
+    iframe.src = url;
+    await new Promise(r => (iframe.onload = r));
+
+    info(`trigger media in iframe entering into fullscreen`);
+    iframe.contentWindow.postMessage("setPositionState", "*");
+  });
+}
diff --git a/dom/media/mediacontrol/tests/browser/browser_media_control_seekto.js b/dom/media/mediacontrol/tests/browser/browser_media_control_seekto.js
new file mode 100644
index 0000000000..70b75841b6
--- /dev/null
+++ b/dom/media/mediacontrol/tests/browser/browser_media_control_seekto.js
@@ -0,0 +1,89 @@
+const PAGE_URL =
+  "https://example.com/browser/dom/media/mediacontrol/tests/browser/file_non_autoplay.html";
+
+const testVideoId = "video";
+
+add_task(async function setupTestingPref() {
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      ["media.mediacontrol.testingevents.enabled", true],
+      ["dom.media.mediasession.enabled", true],
+    ],
+  });
+});
+
+/**
+ * This test is used to check if the `seekto` action can be sent when calling
+ * media controller's `seekTo()`. In addition, the seeking related properties
+ * which would be sent to the action handler should also be correct as what we
+ * set in `seekTo()`.
+ */
+add_task(async function testSetPositionState() {
+  info(`open media page`);
+  const tab = await createLoadedTabWrapper(PAGE_URL);
+
+  info(`start media`);
+  await playMedia(tab, testVideoId);
+
+  const seektime = 0;
+  info(`seek to ${seektime} seconds.`);
+  await PerformSeekTo(tab, {
+    seekTime: seektime,
+  });
+
+  info(`seek to ${seektime} seconds and set fastseek to boolean`);
+  await PerformSeekTo(tab, {
+    seekTime: seektime,
+    fastSeek: true,
+  });
+
+  info(`seek to ${seektime} seconds and set fastseek to false`);
+  await PerformSeekTo(tab, {
+    seekTime: seektime,
+    fastSeek: false,
+  });
+
+  info(`remove tab`);
+  await tab.close();
+});
+
+/**
+ * The following is helper function.
+ */
+async function PerformSeekTo(tab, seekDetails) {
+  await SpecialPowers.spawn(
+    tab.linkedBrowser,
+    [seekDetails, testVideoId],
+    (seekDetails, Id) => {
+      const { seekTime, fastSeek } = seekDetails;
+      content.navigator.mediaSession.setActionHandler("seekto", details => {
+        ok(details.seekTime != undefined, "Seektime must be presented");
+        is(seekTime, details.seekTime, "Get correct seektime");
+        if (fastSeek) {
+          is(fastSeek, details.fastSeek, "Get correct fastSeek");
+        } else {
+          ok(
+            details.fastSeek === undefined,
+            "Details should not contain fastSeek"
+          );
+        }
+        // We use `onseek` as a hint to know if the `seekto` has been received
+        // or not. The reason we don't return a resolved promise instead is
+        // because if we do so, it can't guarantees that the `seekto` action
+        // handler has been set before calling `mediaController.seekTo`.
+        content.document.getElementById(Id).currentTime = seekTime;
+      });
+    }
+  );
+  const seekPromise = SpecialPowers.spawn(
+    tab.linkedBrowser,
+    [testVideoId],
+    Id => {
+      const video = content.document.getElementById(Id);
+      return new Promise(r => (video.onseeking = r()));
+    }
+  );
+  const { seekTime, fastSeek } = seekDetails;
+  tab.linkedBrowser.browsingContext.mediaController.seekTo(seekTime, fastSeek);
+  await seekPromise;
+}
diff --git a/dom/media/mediacontrol/tests/browser/browser_media_control_stop_timer.js b/dom/media/mediacontrol/tests/browser/browser_media_control_stop_timer.js
new file mode 100644
index 0000000000..34fc10badd
--- /dev/null
+++ b/dom/media/mediacontrol/tests/browser/browser_media_control_stop_timer.js
@@ -0,0 +1,79 @@
+// Import this in order to use `triggerPictureInPicture()`.
+Services.scriptloader.loadSubScript(
+  "chrome://mochitests/content/browser/toolkit/components/pictureinpicture/tests/head.js",
+  this
+);
+
+const PAGE_NON_AUTOPLAY =
+  "https://example.com/browser/dom/media/mediacontrol/tests/browser/file_non_autoplay.html";
+
+const testVideoId = "video";
+
+add_task(async function setupTestingPref() {
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      ["media.mediacontrol.testingevents.enabled", true],
+      ["media.mediacontrol.stopcontrol.timer", true],
+      ["media.mediacontrol.stopcontrol.timer.ms", 0],
+    ],
+  });
+});
+
+/**
+ * This test is used to check the stop timer for media element, which would stop
+ * media control for the specific element when the element has been paused over
+ * certain length of time. (That is controlled by the value of the pref
+ * `media.mediacontrol.stopcontrol.timer.ms`) In this test, we set the pref to 0
+ * which means the stop timer would be triggered after the media is paused.
+ * However, if the media is being used in PIP mode, we won't start the stop
+ * timer for it.
+ */
+add_task(async function testStopMediaControlAfterPausingMedia() {
+  info(`open media page`);
+  const tab = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY);
+
+  info(`start media`);
+  await playMedia(tab, testVideoId);
+
+  info(`pause media and the stop timer would stop media control`);
+  await pauseMediaAndMediaControlShouldBeStopped(tab, testVideoId);
+
+  info(`remove tab`);
+  await tab.close();
+});
+
+add_task(async function testNotToStopMediaControlForPIPVideo() {
+  info(`open media page`);
+  const tab = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY);
+
+  info(`start media`);
+  await playMedia(tab, testVideoId);
+
+  info(`trigger PIP mode`);
+  const winPIP = await triggerPictureInPicture(tab.linkedBrowser, testVideoId);
+
+  info(`pause media and the stop timer would not stop media control`);
+  await pauseMedia(tab, testVideoId);
+
+  info(`pressing 'play' key should start PIP video again`);
+  await generateMediaControlKeyEvent("play");
+  await checkOrWaitUntilMediaStartedPlaying(tab, testVideoId);
+
+  info(`remove tab`);
+  await BrowserTestUtils.closeWindow(winPIP);
+  await tab.close();
+});
+
+/**
+ * The following is helper function.
+ */
+function pauseMediaAndMediaControlShouldBeStopped(tab, elementId) {
+  // After pausing media, the stop timer would be triggered and stop the media
+  // control.
+  return Promise.all([
+    new Promise(r => (tab.controller.ondeactivated = r)),
+    SpecialPowers.spawn(tab.linkedBrowser, [elementId], Id => {
+      content.document.getElementById(Id).pause();
+    }),
+  ]);
+}
diff --git a/dom/media/mediacontrol/tests/browser/browser_media_control_supported_keys.js b/dom/media/mediacontrol/tests/browser/browser_media_control_supported_keys.js
new file mode 100644
index 0000000000..2312e90c88
--- /dev/null
+++ b/dom/media/mediacontrol/tests/browser/browser_media_control_supported_keys.js
@@ -0,0 +1,130 @@
+const PAGE_NON_AUTOPLAY =
+  "https://example.com/browser/dom/media/mediacontrol/tests/browser/file_non_autoplay.html";
+
+const testVideoId = "video";
+const sDefaultSupportedKeys = ["focus", "play", "pause", "playpause", "stop"];
+
+add_task(async function setupTestingPref() {
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      ["media.mediacontrol.testingevents.enabled", true],
+      ["dom.media.mediasession.enabled", true],
+    ],
+  });
+});
+
+/**
+ * Supported media keys are used for indicating what UI button should be shown
+ * on the virtual control interface. All supported media keys are listed in
+ * `MediaKey` in `MediaController.webidl`. Some media keys are defined as
+ * default media keys which are always supported. Otherwise, other media keys
+ * have to have corresponding action handler on the active media session in
+ * order to be added to the supported keys.
+ */
+add_task(async function testDefaultSupportedKeys() {
+  info(`open media page`);
+  const tab = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY);
+
+  info(`start media`);
+  await playMedia(tab, testVideoId);
+
+  info(`should use default supported keys`);
+  await supportedKeysShouldEqualTo(tab, sDefaultSupportedKeys);
+
+  info(`remove tab`);
+  await tab.close();
+});
+
+add_task(async function testNoActionHandlerBeingSet() {
+  info(`open media page`);
+  const tab = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY);
+
+  info(`start media`);
+  await playMedia(tab, testVideoId);
+
+  info(`create media session but not set any action handler`);
+  await setMediaSessionSupportedAction(tab, []);
+
+  info(
+    `should use default supported keys even if ` +
+      `media session doesn't have any action handler`
+  );
+  await supportedKeysShouldEqualTo(tab, sDefaultSupportedKeys);
+
+  info(`remove tab`);
+  await tab.close();
+});
+
+add_task(async function testSettingActionsWhichAreAlreadyDefaultKeys() {
+  info(`open media page`);
+  const tab = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY);
+
+  info(`start media`);
+  await playMedia(tab, testVideoId);
+
+  info(`create media session but not set any action handler`);
+  await setMediaSessionSupportedAction(tab, ["play", "pause", "stop"]);
+
+  info(
+    `those actions has already been included in default supported keys, so ` +
+      `the result should still be default supported keys`
+  );
+  await supportedKeysShouldEqualTo(tab, sDefaultSupportedKeys);
+
+  info(`remove tab`);
+  await tab.close();
+});
+
+add_task(async function testSettingActionsWhichAreNotDefaultKeys() {
+  info(`open media page`);
+  const tab = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY);
+
+  info(`start media`);
+  await playMedia(tab, testVideoId);
+
+  info(`create media session but not set any action handler`);
+  let nonDefaultActions = [
+    "seekbackward",
+    "seekforward",
+    "previoustrack",
+    "nexttrack",
+  ];
+  await setMediaSessionSupportedAction(tab, nonDefaultActions);
+
+  info(
+    `supported keys should include those actions which are not default supported keys`
+  );
+  let expectedKeys = sDefaultSupportedKeys.concat(nonDefaultActions);
+  await supportedKeysShouldEqualTo(tab, expectedKeys);
+
+  info(`remove tab`);
+  await tab.close();
+});
+
+/**
+ * The following are helper functions.
+ */
+async function supportedKeysShouldEqualTo(tab, expectedKeys) {
+  const controller = tab.linkedBrowser.browsingContext.mediaController;
+  const supportedKeys = controller.supportedKeys;
+  while (JSON.stringify(expectedKeys) != JSON.stringify(supportedKeys)) {
+    await new Promise(r => (controller.onsupportedkeyschange = r));
+  }
+  for (let idx = 0; idx < expectedKeys.length; idx++) {
+    is(
+      supportedKeys[idx],
+      expectedKeys[idx],
+      `'${supportedKeys[idx]}' should equal to '${expectedKeys[idx]}'`
+    );
+  }
+}
+
+function setMediaSessionSupportedAction(tab, actions) {
+  return SpecialPowers.spawn(tab.linkedBrowser, [actions], actionArr => {
+    for (let action of actionArr) {
+      content.navigator.mediaSession.setActionHandler(action, () => {
+        info(`set '${action}' action handler`);
+      });
+    }
+  });
+}
diff --git a/dom/media/mediacontrol/tests/browser/browser_nosrc_and_error_media.js b/dom/media/mediacontrol/tests/browser/browser_nosrc_and_error_media.js
new file mode 100644
index 0000000000..837b0ecda6
--- /dev/null
+++ b/dom/media/mediacontrol/tests/browser/browser_nosrc_and_error_media.js
@@ -0,0 +1,102 @@
+// Import this in order to use `triggerPictureInPicture()`.
+Services.scriptloader.loadSubScript(
+  "chrome://mochitests/content/browser/toolkit/components/pictureinpicture/tests/head.js",
+  this
+);
+
+const PAGE_NOSRC_MEDIA =
+  "https://example.com/browser/dom/media/mediacontrol/tests/browser/file_no_src_media.html";
+const PAGE_ERROR_MEDIA =
+  "https://example.com/browser/dom/media/mediacontrol/tests/browser/file_error_media.html";
+const PAGES = [PAGE_NOSRC_MEDIA, PAGE_ERROR_MEDIA];
+const testVideoId = "video";
+
+add_task(async function setupTestingPref() {
+  await SpecialPowers.pushPrefEnv({
+    set: [["media.mediacontrol.testingevents.enabled", true]],
+  });
+});
+
+/**
+ * To ensure the no src media and media with error won't activate the media
+ * controller even if they enters PIP mode or fullscreen.
+ */
+add_task(async function testNoSrcOrErrorMediaEntersPIPMode() {
+  for (let page of PAGES) {
+    info(`open media page ${page}`);
+    const tab = await createLoadedTabWrapper(page, { needCheck: false });
+
+    info(`controller should always inactive`);
+    const controller = tab.linkedBrowser.browsingContext.mediaController;
+    controller.onactivated = () => {
+      ok(false, "should not get activated!");
+    };
+
+    info(`enter PIP mode which would not affect controller`);
+    const winPIP = await triggerPictureInPicture(
+      tab.linkedBrowser,
+      testVideoId
+    );
+    info(`leave PIP mode`);
+    await ensureMessageAndClosePiP(
+      tab.linkedBrowser,
+      testVideoId,
+      winPIP,
+      false
+    );
+    ok(!controller.isActive, "controller is still inactive");
+
+    info(`remove tab`);
+    await tab.close();
+  }
+});
+
+add_task(async function testNoSrcOrErrorMediaEntersFullscreen() {
+  for (let page of PAGES) {
+    info(`open media page ${page}`);
+    const tab = await createLoadedTabWrapper(page, { needCheck: false });
+
+    info(`controller should always inactive`);
+    const controller = tab.linkedBrowser.browsingContext.mediaController;
+    controller.onactivated = () => {
+      ok(false, "should not get activated!");
+    };
+
+    info(`enter and leave fullscreen which would not affect controller`);
+    await enterAndLeaveFullScreen(tab, testVideoId);
+    ok(!controller.isActive, "controller is still inactive");
+
+    info(`remove tab`);
+    await tab.close();
+  }
+});
+
+/**
+ * The following is helper function.
+ */
+async function enterAndLeaveFullScreen(tab, elementId) {
+  await new Promise(resolve =>
+    SimpleTest.waitForFocus(resolve, tab.linkedBrowser.ownerGlobal)
+  );
+  await SpecialPowers.spawn(tab.linkedBrowser, [elementId], elementId => {
+    return new Promise(r => {
+      const element = content.document.getElementById(elementId);
+      ok(!content.document.fullscreenElement, "no fullscreen element");
+      element.requestFullscreen();
+      element.onfullscreenchange = () => {
+        if (content.document.fullscreenElement) {
+          element.onfullscreenerror = null;
+          content.document.exitFullscreen();
+        } else {
+          element.onfullscreenchange = null;
+          element.onfullscreenerror = null;
+          r();
+        }
+      };
+      element.onfullscreenerror = () => {
+        // Retry until the element successfully enters fullscreen.
+        element.requestFullscreen();
+      };
+    });
+  });
+}
diff --git a/dom/media/mediacontrol/tests/browser/browser_only_control_non_real_time_media.js b/dom/media/mediacontrol/tests/browser/browser_only_control_non_real_time_media.js
new file mode 100644
index 0000000000..76cf8b0ffd
--- /dev/null
+++ b/dom/media/mediacontrol/tests/browser/browser_only_control_non_real_time_media.js
@@ -0,0 +1,76 @@
+const PAGE_URL =
+  "https://example.com/browser/dom/media/mediacontrol/tests/browser/file_empty_title.html";
+
+/**
+ * This test is used to ensure that real-time media won't be affected by the
+ * media control. Only non-real-time media would.
+ */
+add_task(async function setupTestingPref() {
+  await SpecialPowers.pushPrefEnv({
+    set: [["media.mediacontrol.testingevents.enabled", true]],
+  });
+});
+
+add_task(async function testOnlyControlNonRealTimeMedia() {
+  const tab = await createLoadedTabWrapper(PAGE_URL);
+  const controller = tab.linkedBrowser.browsingContext.mediaController;
+  await StartRealTimeMedia(tab);
+  ok(
+    !controller.isActive,
+    "starting a real-time media won't acivate controller"
+  );
+
+  info(`playing a non-real-time media would activate controller`);
+  await Promise.all([
+    new Promise(r => (controller.onactivated = r)),
+    startNonRealTimeMedia(tab),
+  ]);
+
+  info(`'pause' action should only pause non-real-time media`);
+  MediaControlService.generateMediaControlKey("pause");
+  await new Promise(r => (controller.onplaybackstatechange = r));
+  await checkIfMediaAreAffectedByMediaControl(tab);
+
+  info(`remove tab`);
+  await tab.close();
+});
+
+async function startNonRealTimeMedia(tab) {
+  return SpecialPowers.spawn(tab.linkedBrowser, [], async _ => {
+    let video = content.document.getElementById("video");
+    if (!video) {
+      ok(false, `can not get the video element!`);
+      return;
+    }
+    await video.play();
+  });
+}
+
+async function StartRealTimeMedia(tab) {
+  return SpecialPowers.spawn(tab.linkedBrowser, [], async _ => {
+    let videoRealTime = content.document.createElement("video");
+    content.document.body.appendChild(videoRealTime);
+    videoRealTime.srcObject = await content.navigator.mediaDevices.getUserMedia(
+      { audio: true, fake: true }
+    );
+    // We want to ensure that the checking of should the media be controlled by
+    // media control would be performed after the element finishes loading the
+    // media stream. Using `autoplay` would trigger the play invocation only
+    // after the element get enough data.
+    videoRealTime.autoplay = true;
+    await new Promise(r => (videoRealTime.onplaying = r));
+  });
+}
+
+async function checkIfMediaAreAffectedByMediaControl(tab) {
+  return SpecialPowers.spawn(tab.linkedBrowser, [], async _ => {
+    const vids = content.document.getElementsByTagName("video");
+    for (let vid of vids) {
+      if (!vid.srcObject) {
+        ok(vid.paused, "non-real-time media should be paused");
+      } else {
+        ok(!vid.paused, "real-time media should not be affected");
+      }
+    }
+  });
+}
diff --git a/dom/media/mediacontrol/tests/browser/browser_remove_controllable_media_for_active_controller.js b/dom/media/mediacontrol/tests/browser/browser_remove_controllable_media_for_active_controller.js
new file mode 100644
index 0000000000..a0aa5af4e9
--- /dev/null
+++ b/dom/media/mediacontrol/tests/browser/browser_remove_controllable_media_for_active_controller.js
@@ -0,0 +1,108 @@
+const PAGE_URL =
+  "https://example.com/browser/dom/media/mediacontrol/tests/browser/file_non_autoplay.html";
+
+const testVideoId = "video";
+
+add_task(async function setupTestingPref() {
+  await SpecialPowers.pushPrefEnv({
+    set: [["media.mediacontrol.testingevents.enabled", true]],
+  });
+});
+
+/**
+ * If an active controller has an active media session, then it can still be
+ * controlled via media key even if there is no controllable media presents.
+ * As active media session could still create other controllable media in its
+ * action handler, it should still receive media key. However, if a controller
+ * doesn't have an active media session, then it won't be controlled via media
+ * key when no controllable media presents.
+ */
+add_task(
+  async function testControllerWithActiveMediaSessionShouldStillBeActiveWhenNoControllableMediaPresents() {
+    info(`open media page`);
+    const tab = await createLoadedTabWrapper(PAGE_URL);
+
+    info(`play media would activate controller and media session`);
+    await setupMediaSession(tab);
+    await playMedia(tab, testVideoId);
+    await checkOrWaitControllerBecomesActive(tab);
+
+    info(`remove playing media so we don't have any controllable media now`);
+    await Promise.all([
+      new Promise(r => (tab.controller.onplaybackstatechange = r)),
+      removePlayingMedia(tab),
+    ]);
+
+    info(`despite that, controller should still be active`);
+    await checkOrWaitControllerBecomesActive(tab);
+
+    info(`active media session can still receive media key`);
+    await ensureActiveMediaSessionReceivedMediaKey(tab);
+
+    info(`remove tab`);
+    await tab.close();
+  }
+);
+
+add_task(
+  async function testControllerWithoutActiveMediaSessionShouldBecomeInactiveWhenNoControllableMediaPresents() {
+    info(`open media page`);
+    const tab = await createLoadedTabWrapper(PAGE_URL);
+
+    info(`play media would activate controller`);
+    await playMedia(tab, testVideoId);
+    await checkOrWaitControllerBecomesActive(tab);
+
+    info(
+      `remove playing media so we don't have any controllable media, which would deactivate controller`
+    );
+    await Promise.all([
+      new Promise(r => (tab.controller.ondeactivated = r)),
+      removePlayingMedia(tab),
+    ]);
+
+    info(`remove tab`);
+    await tab.close();
+  }
+);
+
+/**
+ * The following are helper functions.
+ */
+function setupMediaSession(tab) {
+  return SpecialPowers.spawn(tab.linkedBrowser, [], _ => {
+    // except `play/pause/stop`, set an action handler for arbitrary key in
+    // order to later verify if the session receives that media key by listening
+    // to session's `onpositionstatechange`.
+    content.navigator.mediaSession.setActionHandler("seekforward", _ => {
+      content.navigator.mediaSession.setPositionState({
+        duration: 60,
+      });
+    });
+  });
+}
+
+async function ensureActiveMediaSessionReceivedMediaKey(tab) {
+  const controller = tab.linkedBrowser.browsingContext.mediaController;
+  const positionChangePromise = new Promise(
+    r => (controller.onpositionstatechange = r)
+  );
+  MediaControlService.generateMediaControlKey("seekforward");
+  await positionChangePromise;
+  ok(true, "active media session received media key");
+}
+
+function removePlayingMedia(tab) {
+  return SpecialPowers.spawn(tab.linkedBrowser, [testVideoId], Id => {
+    content.document.getElementById(Id).remove();
+  });
+}
+
+async function checkOrWaitControllerBecomesActive(tab) {
+  const controller = tab.linkedBrowser.browsingContext.mediaController;
+  if (!controller.isActive) {
+    info(`wait until controller gets activated`);
+    await new Promise(r => (controller.onactivated = r));
+  }
+  ok(controller.isActive, `controller is active`);
+}
diff --git a/dom/media/mediacontrol/tests/browser/browser_resume_latest_paused_media.js b/dom/media/mediacontrol/tests/browser/browser_resume_latest_paused_media.js
new file mode 100644
index 0000000000..58cd3f5a0f
--- /dev/null
+++ b/dom/media/mediacontrol/tests/browser/browser_resume_latest_paused_media.js
@@ -0,0 +1,189 @@
+const PAGE_URL =
+  "https://example.com/browser/dom/media/mediacontrol/tests/browser/file_multiple_audible_media.html";
+
+add_task(async function setupTestingPref() {
+  await SpecialPowers.pushPrefEnv({
+    set: [["media.mediacontrol.testingevents.enabled", true]],
+  });
+});
+
+/**
+ * This test is used to check when resuming media, we would only resume latest
+ * paused media, not all media in the page.
+ */
+add_task(async function testResumingLatestPausedMedias() {
+  info(`open media page and play all media`);
+  const tab = await createLoadedTabWrapper(PAGE_URL);
+  await playAllMedia(tab);
+
+  /**
+   * Pressing `pause` key would pause video1, video2, video3
+   * So resuming from media control key would affect those three media
+   */
+  info(`pressing 'pause' should pause all media`);
+  await generateMediaControlKeyEvent("pause");
+  await checkMediaPausedState(tab, {
+    shouldVideo1BePaused: true,
+    shouldVideo2BePaused: true,
+    shouldVideo3BePaused: true,
+  });
+
+  info(`all media are latest paused, pressing 'play' should resume all`);
+  await generateMediaControlKeyEvent("play");
+  await checkMediaPausedState(tab, {
+    shouldVideo1BePaused: false,
+    shouldVideo2BePaused: false,
+    shouldVideo3BePaused: false,
+  });
+
+  info(`pause only one playing video by calling its webidl method`);
+  await pauseMedia(tab, "video3");
+  await checkMediaPausedState(tab, {
+    shouldVideo1BePaused: false,
+    shouldVideo2BePaused: false,
+    shouldVideo3BePaused: true,
+  });
+
+  /**
+   * Pressing `pause` key would pause video1, video2
+   * So resuming from media control key would affect those two media
+   */
+  info(`pressing 'pause' should pause two playing media`);
+  await generateMediaControlKeyEvent("pause");
+  await checkMediaPausedState(tab, {
+    shouldVideo1BePaused: true,
+    shouldVideo2BePaused: true,
+    shouldVideo3BePaused: true,
+  });
+
+  info(`two media are latest paused, pressing 'play' should only affect them`);
+  await generateMediaControlKeyEvent("play");
+  await checkMediaPausedState(tab, {
+    shouldVideo1BePaused: false,
+    shouldVideo2BePaused: false,
+    shouldVideo3BePaused: true,
+  });
+
+  info(`pause only one playing video by calling its webidl method`);
+  await pauseMedia(tab, "video2");
+  await checkMediaPausedState(tab, {
+    shouldVideo1BePaused: false,
+    shouldVideo2BePaused: true,
+    shouldVideo3BePaused: true,
+  });
+
+  /**
+   * Pressing `pause` key would pause video1
+   * So resuming from media control key would only affect one media
+   */
+  info(`pressing 'pause' should pause one playing media`);
+  await generateMediaControlKeyEvent("pause");
+  await checkMediaPausedState(tab, {
+    shouldVideo1BePaused: true,
+    shouldVideo2BePaused: true,
+    shouldVideo3BePaused: true,
+  });
+
+  info(`one media is latest paused, pressing 'play' should only affect it`);
+  await generateMediaControlKeyEvent("play");
+  await checkMediaPausedState(tab, {
+    shouldVideo1BePaused: false,
+    shouldVideo2BePaused: true,
+    shouldVideo3BePaused: true,
+  });
+
+  /**
+   * Only one media is playing, so pausing it should not stop controlling media.
+   * We should still be able to resume it later.
+   */
+  info(`pause only playing video by calling its webidl method`);
+  await pauseMedia(tab, "video1");
+  await checkMediaPausedState(tab, {
+    shouldVideo1BePaused: true,
+    shouldVideo2BePaused: true,
+    shouldVideo3BePaused: true,
+  });
+
+  info(`pressing 'pause' for already paused media, nothing would happen`);
+  // All media are already paused, so no need to wait for playback state change,
+  // call the method directly.
+  MediaControlService.generateMediaControlKey("pause");
+
+  info(`pressing 'play' would still affect on latest paused media`);
+  await generateMediaControlKeyEvent("play");
+  await checkMediaPausedState(tab, {
+    shouldVideo1BePaused: false,
+    shouldVideo2BePaused: true,
+    shouldVideo3BePaused: true,
+  });
+
+  info(`remove tab`);
+  await tab.close();
+});
+
+/**
+ * The following are helper functions.
+ */
+async function playAllMedia(tab) {
+  const playbackStateChangedPromise = waitUntilDisplayedPlaybackChanged();
+  await SpecialPowers.spawn(tab.linkedBrowser, [], () => {
+    return new Promise(r => {
+      const videos = content.document.getElementsByTagName("video");
+      let mediaCount = 0;
+      docShell.chromeEventHandler.addEventListener(
+        "MozStartMediaControl",
+        () => {
+          if (++mediaCount == videos.length) {
+            info(`all media have started media control`);
+            r();
+          }
+        }
+      );
+      for (let video of videos) {
+        info(`play ${video.id} video`);
+        video.play();
+      }
+    });
+  });
+  await playbackStateChangedPromise;
+}
+
+async function pauseMedia(tab, videoId) {
+  await SpecialPowers.spawn(tab.linkedBrowser, [videoId], videoId => {
+    const video = content.document.getElementById(videoId);
+    if (!video) {
+      ok(false, `can not find ${videoId}!`);
+    }
+    video.pause();
+  });
+}
+
+function checkMediaPausedState(
+  tab,
+  { shouldVideo1BePaused, shouldVideo2BePaused, shouldVideo3BePaused }
+) {
+  return SpecialPowers.spawn(
+    tab.linkedBrowser,
+    [shouldVideo1BePaused, shouldVideo2BePaused, shouldVideo3BePaused],
+    (shouldVideo1BePaused, shouldVideo2BePaused, shouldVideo3BePaused) => {
+      const video1 = content.document.getElementById("video1");
+      const video2 = content.document.getElementById("video2");
+      const video3 = content.document.getElementById("video3");
+      is(
+        video1.paused,
+        shouldVideo1BePaused,
+        "Correct paused state for video1"
+      );
+      is(
+        video2.paused,
+        shouldVideo2BePaused,
+        "Correct paused state for video2"
+      );
+      is(
+        video3.paused,
+        shouldVideo3BePaused,
+        "Correct paused state for video3"
+      );
+    }
+  );
+}
diff --git a/dom/media/mediacontrol/tests/browser/browser_seek_captured_audio.js b/dom/media/mediacontrol/tests/browser/browser_seek_captured_audio.js
new file mode 100644
index 0000000000..3dbbee065e
--- /dev/null
+++ b/dom/media/mediacontrol/tests/browser/browser_seek_captured_audio.js
@@ -0,0 +1,59 @@
+const PAGE_NON_AUTOPLAY_MEDIA =
+  "https://example.com/browser/dom/media/mediacontrol/tests/browser/file_non_autoplay.html";
+
+const testVideoId = "video";
+
+add_task(async function setupTestingPref() {
+  await SpecialPowers.pushPrefEnv({
+    set: [["media.mediacontrol.testingevents.enabled", true]],
+  });
+});
+
+/**
+ * Seeking a captured audio media before it starts, and it should still be able
+ * to be controlled via media key after it starts playing.
+ */
+add_task(async function testSeekAudibleCapturedMedia() {
+  info(`open new non autoplay media page`);
+  const tab = await createLoadedTabWrapper(PAGE_NON_AUTOPLAY_MEDIA);
+
+  info(`perform seek on the captured media before it starts`);
+  await captureAudio(tab, testVideoId);
+  await seekAudio(tab, testVideoId);
+
+  info(`start captured media`);
+  await playMedia(tab, testVideoId);
+
+  info(`pressing 'pause' key, captured media should be paused`);
+  await generateMediaControlKeyEvent("pause");
+  await checkOrWaitUntilMediaStoppedPlaying(tab, testVideoId);
+
+  info(`remove tab`);
+  await tab.close();
+});
+
+/**
+ * The following are helper functions.
+ */
+function captureAudio(tab, elementId) {
+  return SpecialPowers.spawn(tab.linkedBrowser, [elementId], Id => {
+    const video = content.document.getElementById(Id);
+    if (!video) {
+      ok(false, `can't get the media element!`);
+    }
+    const context = new content.AudioContext();
+    // Capture audio from the media element to a MediaElementAudioSourceNode.
+    context.createMediaElementSource(video);
+  });
+}
+
+function seekAudio(tab, elementId) {
+  return SpecialPowers.spawn(tab.linkedBrowser, [elementId], async Id => {
+    const video = content.document.getElementById(Id);
+    if (!video) {
+      ok(false, `can't get the media element!`);
+    }
+    video.currentTime = 0.0;
+    await new Promise(r => (video.onseeked = r));
+  });
+}
diff --git a/dom/media/mediacontrol/tests/browser/browser_stop_control_after_media_reaches_to_end.js b/dom/media/mediacontrol/tests/browser/browser_stop_control_after_media_reaches_to_end.js
new file mode 100644
index 0000000000..cc8ccf270a
--- /dev/null
+++ b/dom/media/mediacontrol/tests/browser/browser_stop_control_after_media_reaches_to_end.js
@@ -0,0 +1,108 @@
+const PAGE_URL =
+  "https://example.com/browser/dom/media/mediacontrol/tests/browser/file_non_looping_media.html";
+
+add_task(async function setupTestingPref() {
+  await SpecialPowers.pushPrefEnv({
+    set: [["media.mediacontrol.stopcontrol.aftermediaends", true]],
+  });
+});
+
+/**
+ * This test is used to ensure that we would stop controlling media after it
+ * reaches to the end when a controller doesn't have an active media session.
+ * If a controller has an active media session, it would keep active despite
+ * media reaches to the end.
+ */
+add_task(async function testControllerShouldStopAfterMediaReachesToTheEnd() {
+  info(`open media page and play media until the end`);
+  const tab = await createLoadedTabWrapper(PAGE_URL);
+  await Promise.all([
+    checkIfMediaControllerBecomeInactiveAfterMediaEnds(tab),
+    playMediaUntilItReachesToTheEnd(tab),
+  ]);
+
+  info(`remove tab`);
+  await tab.close();
+});
+
+add_task(async function testControllerWontStopAfterMediaReachesToTheEnd() {
+  info(`open media page and create media session`);
+  const tab = await createLoadedTabWrapper(PAGE_URL);
+  await createMediaSession(tab);
+
+  info(`play media until the end`);
+  await playMediaUntilItReachesToTheEnd(tab);
+
+  info(`controller is still active because of having active media session`);
+  await checkControllerIsActive(tab);
+
+  info(`remove tab`);
+  await tab.close();
+});
+
+/**
+ * The following are helper functions.
+ */
+function checkIfMediaControllerBecomeInactiveAfterMediaEnds(tab) {
+  return new Promise(r => {
+    let activeChangedNums = 0;
+    const controller = tab.linkedBrowser.browsingContext.mediaController;
+    controller.onactivated = () => {
+      is(
+        ++activeChangedNums,
+        1,
+        `Receive ${activeChangedNums} times 'onactivechange'`
+      );
+      // We activate controller when it becomes playing, which doesn't guarantee
+      // it's already audible, so we won't check audible state here.
+      ok(controller.isActive, "controller should be active");
+      ok(controller.isPlaying, "controller should be playing");
+    };
+    controller.ondeactivated = () => {
+      is(
+        ++activeChangedNums,
+        2,
+        `Receive ${activeChangedNums} times 'onactivechange'`
+      );
+      ok(!controller.isActive, "controller should be inactive");
+      ok(!controller.isAudible, "controller should be inaudible");
+      ok(!controller.isPlaying, "controller should be paused");
+      r();
+    };
+  });
+}
+
+function playMediaUntilItReachesToTheEnd(tab) {
+  return SpecialPowers.spawn(tab.linkedBrowser, [], async () => {
+    const video = content.document.getElementById("video");
+    if (!video) {
+      ok(false, "can't get video");
+    }
+
+    if (video.readyState < video.HAVE_METADATA) {
+      info(`load media to get its duration`);
+      video.load();
+      await new Promise(r => (video.loadedmetadata = r));
+    }
+
+    info(`adjust the start position to faster reach to the end`);
+    ok(video.duration > 1.0, "video's duration is larger than 1.0s");
+    video.currentTime = video.duration - 1.0;
+
+    info(`play ${video.id} video`);
+    video.play();
+    await new Promise(r => (video.onended = r));
+  });
+}
+
+function createMediaSession(tab) {
+  return SpecialPowers.spawn(tab.linkedBrowser, [], _ => {
+    // simply create a media session, which would become the active media session later.
+    content.navigator.mediaSession;
+  });
+}
+
+function checkControllerIsActive(tab) {
+  const controller = tab.linkedBrowser.browsingContext.mediaController;
+  ok(controller.isActive, `controller is active`);
+}
diff --git a/dom/media/mediacontrol/tests/browser/browser_suspend_inactive_tab.js b/dom/media/mediacontrol/tests/browser/browser_suspend_inactive_tab.js
new file mode 100644
index 0000000000..334717a2f2
--- /dev/null
+++ b/dom/media/mediacontrol/tests/browser/browser_suspend_inactive_tab.js
@@ -0,0 +1,131 @@
+const PAGE_NON_AUTOPLAY =
+  "https://example.com/browser/dom/media/mediacontrol/tests/browser/file_non_autoplay.html";
+const VIDEO_ID = "video";
+
+add_task(async function setupTestingPref() {
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      ["media.mediacontrol.testingevents.enabled", true],
+      ["dom.suspend_inactive.enabled", true],
+      ["dom.audiocontext.testing", true],
+    ],
+  });
+});
+
+/**
+ * This test to used to test the feature that would suspend the inactive tab,
+ * which currently is only used on Android.
+ *
+ * Normally when tab becomes inactive, we would suspend it and stop its script
+ * from running. However, if a tab has a main controller, which indicates it
+ * might have playng media, or waiting media keys to control media, then it
+ * would not be suspended event if it's inactive.
+ *
+ * In addition, Note that, on Android, audio focus management is enabled by
+ * default, so there is only one tab being able to play at a time, which means
+ * the tab playing media always has main controller.
+ */
+add_task(async function testInactiveTabWouldBeSuspended() {
+  info(`open a tab`);
+  const tab = await createTab(PAGE_NON_AUTOPLAY);
+  await assertIfWindowGetSuspended(tab, { shouldBeSuspended: false });
+
+  info(`tab should be suspended when it becomes inactive`);
+  setTabActive(tab, false);
+  await assertIfWindowGetSuspended(tab, { shouldBeSuspended: true });
+
+  info(`remove tab`);
+  await tab.close();
+});
+
+add_task(async function testInactiveTabEverStartPlayingWontBeSuspended() {
+  info(`open tab1 and play media`);
+  const tab1 = await createTab(PAGE_NON_AUTOPLAY, { needCheck: true });
+  await assertIfWindowGetSuspended(tab1, { shouldBeSuspended: false });
+  await playMedia(tab1, VIDEO_ID);
+
+  info(`tab with playing media won't be suspended when it becomes inactive`);
+  setTabActive(tab1, false);
+  await assertIfWindowGetSuspended(tab1, { shouldBeSuspended: false });
+
+  info(
+    `even if media is paused, keep tab running so that it could listen to media keys to control media in the future`
+  );
+  await pauseMedia(tab1, VIDEO_ID);
+  await assertIfWindowGetSuspended(tab1, { shouldBeSuspended: false });
+
+  info(`open tab2 and play media`);
+  const tab2 = await createTab(PAGE_NON_AUTOPLAY, { needCheck: true });
+  await assertIfWindowGetSuspended(tab2, { shouldBeSuspended: false });
+  await playMedia(tab2, VIDEO_ID);
+
+  info(
+    `as inactive tab1 doesn't own main controller, it should be suspended again`
+  );
+  await assertIfWindowGetSuspended(tab1, { shouldBeSuspended: true });
+
+  info(`remove tabs`);
+  await Promise.all([tab1.close(), tab2.close()]);
+});
+
+add_task(
+  async function testInactiveTabWithRunningAudioContextWontBeSuspended() {
+    info(`open tab and start an audio context (AC)`);
+    const tab = await createTab("about:blank");
+    await startAudioContext(tab);
+    await assertIfWindowGetSuspended(tab, { shouldBeSuspended: false });
+
+    info(`tab with running AC won't be suspended when it becomes inactive`);
+    setTabActive(tab, false);
+    await assertIfWindowGetSuspended(tab, { shouldBeSuspended: false });
+
+    info(`if AC has been suspended, then inactive tab should be suspended`);
+    await suspendAudioContext(tab);
+    await assertIfWindowGetSuspended(tab, { shouldBeSuspended: true });
+
+    info(`remove tab`);
+    await tab.close();
+  }
+);
+
+/**
+ * The following are helper functions.
+ */
+async function createTab(url, needCheck = false) {
+  const tab = await createLoadedTabWrapper(url, { needCheck });
+  return tab;
+}
+
+function assertIfWindowGetSuspended(tab, { shouldBeSuspended }) {
+  return SpecialPowers.spawn(
+    tab.linkedBrowser,
+    [shouldBeSuspended],
+    expectedSuspend => {
+      const isSuspended = content.windowUtils.suspendedByBrowsingContextGroup;
+      is(
+        expectedSuspend,
+        isSuspended,
+        `window suspended state (${isSuspended}) is equal to the expected`
+      );
+    }
+  );
+}
+
+function setTabActive(tab, isActive) {
+  tab.linkedBrowser.docShellIsActive = isActive;
+}
+
+function startAudioContext(tab) {
+  return SpecialPowers.spawn(tab.linkedBrowser, [], async _ => {
+    content.ac = new content.AudioContext();
+    await new Promise(r => (content.ac.onstatechange = r));
+    ok(content.ac.state == "running", `Audio context started running`);
+  });
+}
+
+function suspendAudioContext(tab) {
+  return SpecialPowers.spawn(tab.linkedBrowser, [], async _ => {
+    await content.ac.suspend();
+    ok(content.ac.state == "suspended", `Audio context is suspended`);
+  });
+}
diff --git a/dom/media/mediacontrol/tests/browser/file_audio_and_inaudible_media.html b/dom/media/mediacontrol/tests/browser/file_audio_and_inaudible_media.html
new file mode 100644
index 0000000000..e16d5dee26
--- /dev/null
+++ b/dom/media/mediacontrol/tests/browser/file_audio_and_inaudible_media.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>page with audible and inaudible media</title>
+</head>
+<body>
+<video id="video1" src="gizmo.mp4" loop></video>
+<video id="video2" src="gizmo.mp4" loop muted></video>
+</body>
+</html>
diff --git a/dom/media/mediacontrol/tests/browser/file_autoplay.html b/dom/media/mediacontrol/tests/browser/file_autoplay.html
new file mode 100644
index 0000000000..97a58ec2a2
--- /dev/null
+++ b/dom/media/mediacontrol/tests/browser/file_autoplay.html
@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html>
+<head>
+	<title>Autoplay page</title>
+</head>
+<body>
+<video id="autoplay" src="gizmo.mp4" autoplay loop></video>
+</body>
+</html>
diff --git a/dom/media/mediacontrol/tests/browser/file_empty_title.html b/dom/media/mediacontrol/tests/browser/file_empty_title.html
new file mode 100644
index 0000000000..516c16036f
--- /dev/null
+++ b/dom/media/mediacontrol/tests/browser/file_empty_title.html
@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title></title>
+</head>
+<body>
+<video id="video" src="gizmo.mp4" loop></video>
+</body>
+</html>
diff --git a/dom/media/mediacontrol/tests/browser/file_error_media.html b/dom/media/mediacontrol/tests/browser/file_error_media.html
new file mode 100644
index 0000000000..7f54340dd1
--- /dev/null
+++ b/dom/media/mediacontrol/tests/browser/file_error_media.html
@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>Error media</title>
+</head>
+<body>
+<video id="video" src="bogus.ogv"></video>
+</body>
+</html>
diff --git a/dom/media/mediacontrol/tests/browser/file_iframe_media.html b/dom/media/mediacontrol/tests/browser/file_iframe_media.html
new file mode 100644
index 0000000000..2d2c4fd122
--- /dev/null
+++ b/dom/media/mediacontrol/tests/browser/file_iframe_media.html
@@ -0,0 +1,94 @@
+<!DOCTYPE html>
+<html>
+<head>
+</head>
+<body>
+<video id="video" src="gizmo.mp4" loop></video>
+<script type="text/javascript">
+
+const video = document.getElementById("video");
+const w = window.opener || window.parent;
+
+window.onmessage = async event => {
+  if (event.data == "fullscreen") {
+    video.requestFullscreen();
+    video.onfullscreenchange = () => {
+      video.onfullscreenchange = null;
+      video.onfullscreenerror = null;
+      w.postMessage("entered-fullscreen", "*");
+    }
+    video.onfullscreenerror = () => {
+      // Retry until the element successfully enters fullscreen.
+      video.requestFullscreen();
+    }
+  } else if (event.data == "check-playing") {
+    if (!video.paused) {
+      w.postMessage("checked-playing", "*");
+    } else {
+      video.onplaying = () => {
+        video.onplaying = null;
+        w.postMessage("checked-playing", "*");
+      }
+    }
+  } else if (event.data == "check-pause") {
+    if (video.paused) {
+      w.postMessage("checked-pause", "*");
+    } else {
+      video.onpause = () => {
+        video.onpause = null;
+        w.postMessage("checked-pause", "*");
+      }
+    }
+  } else if (event.data == "play") {
+    await video.play();
+    w.postMessage("played", "*");
+  } else if (event.data == "pause") {
+    video.pause();
+    w.postMessage("paused", "*");
+  } else if (event.data == "setMetadata") {
+    const metadata = {
+      title: document.title,
+      artist: document.title,
+      album: document.title,
+      artwork: [{ src: document.title, sizes: "128x128", type: "image/jpeg" }],
+    };
+    navigator.mediaSession.metadata = new window.MediaMetadata(metadata);
+    w.postMessage(metadata, "*");
+  } else if (event.data == "setPositionState") {
+    navigator.mediaSession.setPositionState({
+      duration: 60, // The value doesn't matter
+    });
+  } else if (event.data.cmd == "setActionHandler") {
+    if (window.triggeredActionHandler === undefined) {
+      window.triggeredActionHandler = {};
+    }
+    const action = event.data.action;
+    window.triggeredActionHandler[action] = new Promise(r => {
+      navigator.mediaSession.setActionHandler(action, async () => {
+        if (action == "stop" || action == "pause") {
+          video.pause();
+        } else if (action == "play") {
+          await video.play();
+        }
+        r();
+      });
+    });
+    w.postMessage("setActionHandler-done", "*");
+  } else if (event.data.cmd == "checkActionHandler") {
+    const action = event.data.action;
+    if (!window.triggeredActionHandler[action]) {
+      w.postMessage("checkActionHandler-fail", "*");
+    } else {
+      await window.triggeredActionHandler[action];
+      w.postMessage("checkActionHandler-done", "*");
+    }
+  } else if (event.data == "create-media-session") {
+    // simply calling a media session would create an instance.
+    navigator.mediaSession;
+    w.postMessage("created-media-session", "*");
+  }
+}
+
+</script>
+</body>
+</html>
diff --git a/dom/media/mediacontrol/tests/browser/file_main_frame_with_multiple_child_session_frames.html b/dom/media/mediacontrol/tests/browser/file_main_frame_with_multiple_child_session_frames.html
new file mode 100644
index 0000000000..f8e7aa9afe
--- /dev/null
+++ b/dom/media/mediacontrol/tests/browser/file_main_frame_with_multiple_child_session_frames.html
@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>Media control page with multiple iframes which contain media session</title>
+</head>
+<body>
+<video id="video" src="gizmo.mp4" loop></video>
+<iframe id="frame1"></iframe>
+<iframe id="frame2"></iframe>
+</body>
+</html>
diff --git a/dom/media/mediacontrol/tests/browser/file_multiple_audible_media.html b/dom/media/mediacontrol/tests/browser/file_multiple_audible_media.html
new file mode 100644
index 0000000000..e78fabe7fa
--- /dev/null
+++ b/dom/media/mediacontrol/tests/browser/file_multiple_audible_media.html
@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>mutiple audible media</title>
+</head>
+<body>
+<video id="video1" src="gizmo.mp4" loop></video>
+<video id="video2" src="gizmo.mp4" loop></video>
+<video id="video3" src="gizmo.mp4" loop></video>
+</body>
+</html>
diff --git a/dom/media/mediacontrol/tests/browser/file_muted_autoplay.html b/dom/media/mediacontrol/tests/browser/file_muted_autoplay.html
new file mode 100644
index 0000000000..f64d537a46
--- /dev/null
+++ b/dom/media/mediacontrol/tests/browser/file_muted_autoplay.html
@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Muted autoplay page</title>
+</head>
+<body>
+<video id="autoplay" src="gizmo.mp4" autoplay loop muted></video>
+</body>
+</html>
diff --git a/dom/media/mediacontrol/tests/browser/file_no_src_media.html b/dom/media/mediacontrol/tests/browser/file_no_src_media.html
new file mode 100644
index 0000000000..e1318e863c
--- /dev/null
+++ b/dom/media/mediacontrol/tests/browser/file_no_src_media.html
@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>No src media</title>
+</head>
+<body>
+<video id="video"></video>
+</body>
+</html>
diff --git a/dom/media/mediacontrol/tests/browser/file_non_autoplay.html b/dom/media/mediacontrol/tests/browser/file_non_autoplay.html
new file mode 100644
index 0000000000..06daa7e2d8
--- /dev/null
+++ b/dom/media/mediacontrol/tests/browser/file_non_autoplay.html
@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>Non-Autoplay page</title>
+</head>
+<body>
+<video id="video" src="gizmo.mp4" loop></video>
+<image id="image" src="data:image/svg+xml;base64,PCEtLSBUaGlzIFNvdXJjZSBDb2RlIEZvcm0gaXMgc3ViamVjdCB0byB0aGUgdGVybXMgb2YgdGhlIE1vemlsbGEgUHVibGljCiAgIC0gTGljZW5zZSwgdi4gMi4wLiBJZiBhIGNvcHkgb2YgdGhlIE1QTCB3YXMgbm90IGRpc3RyaWJ1dGVkIHdpdGggdGhpcwogICAtIGZpbGUsIFlvdSBjYW4gb2J0YWluIG9uZSBhdCBodHRwOi8vbW96aWxsYS5vcmcvTVBMLzIuMC8uIC0tPgo8c3ZnIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgd2lkdGg9IjE2IiBoZWlnaHQ9IjE2IiB2aWV3Qm94PSIwIDAgMTYgMTYiPgogIDxwYXRoIGZpbGw9ImNvbnRleHQtZmlsbCIgZmlsbC1vcGFjaXR5PSJjb250ZXh0LWZpbGwtb3BhY2l0eSIgZD0iTTggMGE4IDggMCAxIDAgOCA4IDguMDA5IDguMDA5IDAgMCAwLTgtOHptNS4xNjMgNC45NThoLTEuNTUyYTcuNyA3LjcgMCAwIDAtMS4wNTEtMi4zNzYgNi4wMyA2LjAzIDAgMCAxIDIuNjAzIDIuMzc2ek0xNCA4YTUuOTYzIDUuOTYzIDAgMCAxLS4zMzUgMS45NThoLTEuODIxQTEyLjMyNyAxMi4zMjcgMCAwIDAgMTIgOGExMi4zMjcgMTIuMzI3IDAgMCAwLS4xNTYtMS45NThoMS44MjFBNS45NjMgNS45NjMgMCAwIDEgMTQgOHptLTYgNmMtMS4wNzUgMC0yLjAzNy0xLjItMi41NjctMi45NThoNS4xMzVDMTAuMDM3IDEyLjggOS4wNzUgMTQgOCAxNHpNNS4xNzQgOS45NThhMTEuMDg0IDExLjA4NCAwIDAgMSAwLTMuOTE2aDUuNjUxQTExLjExNCAxMS4xMTQgMCAwIDEgMTEgOGExMS4xMTQgMTEuMTE0IDAgMCAxLS4xNzQgMS45NTh6TTIgOGE1Ljk2MyA1Ljk2MyAwIDAgMSAuMzM1LTEuOTU4aDEuODIxYTEyLjM2MSAxMi4zNjEgMCAwIDAgMCAzLjkxNkgyLjMzNUE1Ljk2MyA1Ljk2MyAwIDAgMSAyIDh6bTYtNmMxLjA3NSAwIDIuMDM3IDEuMiAyLjU2NyAyLjk1OEg1LjQzM0M1Ljk2MyAzLjIgNi45MjUgMiA4IDJ6bS0yLjU2LjU4MmE3LjcgNy43IDAgMCAwLTEuMDUxIDIuMzc2SDIuODM3QTYuMDMgNi4wMyAwIDAgMSA1LjQ0IDIuNTgyem0tMi42IDguNDZoMS41NDlhNy43IDcuNyAwIDAgMCAxLjA1MSAyLjM3NiA2LjAzIDYuMDMgMCAwIDEtMi42MDMtMi4zNzZ6bTcuNzIzIDIuMzc2YTcuNyA3LjcgMCAwIDAgMS4wNTEtMi4zNzZoMS41NTJhNi4wMyA2LjAzIDAgMCAxLTIuNjA2IDIuMzc2eiIvPgo8L3N2Zz4K">
+<iframe id="iframe" allow="fullscreen *" allowfullscreen></iframe>
+</body>
+</html>
diff --git a/dom/media/mediacontrol/tests/browser/file_non_eligible_media.html b/dom/media/mediacontrol/tests/browser/file_non_eligible_media.html
new file mode 100644
index 0000000000..bf27943fce
--- /dev/null
+++ b/dom/media/mediacontrol/tests/browser/file_non_eligible_media.html
@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>Media are not eligible to be controlled</title>
+</head>
+<body>
+<video id="muted" src="gizmo.mp4" controls muted loop></video>
+<video id="volume-0" src="gizmo.mp4" controls loop></video>
+<video id="no-audio-track" src="gizmo-noaudio.webm"  controls loop></video>
+<video id="silent-audio-track" src="silentAudioTrack.webm" controls loop></video>
+<video id="short-duration" src="gizmo-short.mp4" controls loop></video>
+<video id="inaudible-captured-media" src="gizmo.mp4" muted controls loop></video>
+</body>
+</html>
diff --git a/dom/media/mediacontrol/tests/browser/file_non_looping_media.html b/dom/media/mediacontrol/tests/browser/file_non_looping_media.html
new file mode 100644
index 0000000000..41e049645c
--- /dev/null
+++ b/dom/media/mediacontrol/tests/browser/file_non_looping_media.html
@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>Non looping media page</title>
+</head>
+<body>
+<video id="video" src="gizmo.mp4"></video>
+</body>
+</html>
diff --git a/dom/media/mediacontrol/tests/browser/head.js b/dom/media/mediacontrol/tests/browser/head.js
new file mode 100644
index 0000000000..cac96c0bff
--- /dev/null
+++ b/dom/media/mediacontrol/tests/browser/head.js
@@ -0,0 +1,402 @@
+/**
+ * This function would create a new foreround tab and load the url for it. In
+ * addition, instead of returning a tab element, we return a tab wrapper that
+ * helps us to automatically detect if the media controller of that tab
+ * dispatches the first (activated) and the last event (deactivated) correctly.
+ * @ param url
+ *         the page url which tab would load
+ * @ param input window (optional)
+ *         if it exists, the tab would be created from the input window. If not,
+ *         then the tab would be created in current window.
+ * @ param needCheck (optional)
+ *         it decides if we would perform the check for the first and last event
+ *         on the media controller. It's default true.
+ */
+async function createLoadedTabWrapper(
+  url,
+  { inputWindow = window, needCheck = true } = {}
+) {
+  class tabWrapper {
+    constructor(tab, needCheck) {
+      this._tab = tab;
+      this._controller = tab.linkedBrowser.browsingContext.mediaController;
+      this._firstEvent = "";
+      this._lastEvent = "";
+      this._events = [
+        "activated",
+        "deactivated",
+        "metadatachange",
+        "playbackstatechange",
+        "positionstatechange",
+        "supportedkeyschange",
+      ];
+      this._needCheck = needCheck;
+      if (this._needCheck) {
+        this._registerAllEvents();
+      }
+    }
+    _registerAllEvents() {
+      for (let event of this._events) {
+        this._controller.addEventListener(event, this._handleEvent.bind(this));
+      }
+    }
+    _unregisterAllEvents() {
+      for (let event of this._events) {
+        this._controller.removeEventListener(
+          event,
+          this._handleEvent.bind(this)
+        );
+      }
+    }
+    _handleEvent(event) {
+      info(`handle event=${event.type}`);
+      if (this._firstEvent === "") {
+        this._firstEvent = event.type;
+      }
+      this._lastEvent = event.type;
+    }
+    get linkedBrowser() {
+      return this._tab.linkedBrowser;
+    }
+    get controller() {
+      return this._controller;
+    }
+    get tabElement() {
+      return this._tab;
+    }
+    async close() {
+      info(`wait until finishing close tab wrapper`);
+      const deactivationPromise = this._controller.isActive
+        ? new Promise(r => (this._controller.ondeactivated = r))
+        : Promise.resolve();
+      BrowserTestUtils.removeTab(this._tab);
+      await deactivationPromise;
+      if (this._needCheck) {
+        is(this._firstEvent, "activated", "First event should be 'activated'");
+        is(
+          this._lastEvent,
+          "deactivated",
+          "Last event should be 'deactivated'"
+        );
+        this._unregisterAllEvents();
+      }
+    }
+  }
+  const browser = inputWindow ? inputWindow.gBrowser : window.gBrowser;
+  let tab = await BrowserTestUtils.openNewForegroundTab(browser, url);
+  return new tabWrapper(tab, needCheck);
+}
+
+/**
+ * Returns a promise that resolves when generated media control keys has
+ * triggered the main media controller's corresponding method and changes its
+ * playback state.
+ *
+ * @param {string} event
+ *        The event name of the media control key
+ * @return {Promise}
+ *         Resolve when the main controller receives the media control key event
+ *         and change its playback state.
+ */
+function generateMediaControlKeyEvent(event) {
+  const playbackStateChanged = waitUntilDisplayedPlaybackChanged();
+  MediaControlService.generateMediaControlKey(event);
+  return playbackStateChanged;
+}
+
+/**
+ * Play the specific media and wait until it plays successfully and the main
+ * controller has been updated.
+ *
+ * @param {tab} tab
+ *        The tab that contains the media which we would play
+ * @param {string} elementId
+ *        The element Id of the media which we would play
+ * @return {Promise}
+ *         Resolve when the media has been starting playing and the main
+ *         controller has been updated.
+ */
+async function playMedia(tab, elementId) {
+  const playbackStatePromise = waitUntilDisplayedPlaybackChanged();
+  await SpecialPowers.spawn(tab.linkedBrowser, [elementId], async Id => {
+    const video = content.document.getElementById(Id);
+    if (!video) {
+      ok(false, `can't get the media element!`);
+    }
+    ok(
+      await video.play().then(
+        _ => true,
+        _ => false
+      ),
+      "video started playing"
+    );
+  });
+  return playbackStatePromise;
+}
+
+/**
+ * Pause the specific media and wait until it pauses successfully and the main
+ * controller has been updated.
+ *
+ * @param {tab} tab
+ *        The tab that contains the media which we would pause
+ * @param {string} elementId
+ *        The element Id of the media which we would pause
+ * @return {Promise}
+ *         Resolve when the media has been paused and the main controller has
+ *         been updated.
+ */
+function pauseMedia(tab, elementId) {
+  const pausePromise = SpecialPowers.spawn(
+    tab.linkedBrowser,
+    [elementId],
+    Id => {
+      const video = content.document.getElementById(Id);
+      if (!video) {
+        ok(false, `can't get the media element!`);
+      }
+      ok(!video.paused, `video is playing before calling pause`);
+      video.pause();
+    }
+  );
+  return Promise.all([pausePromise, waitUntilDisplayedPlaybackChanged()]);
+}
+
+/**
+ * Returns a promise that resolves when the specific media starts playing.
+ *
+ * @param {tab} tab
+ *        The tab that contains the media which we would check
+ * @param {string} elementId
+ *        The element Id of the media which we would check
+ * @return {Promise}
+ *         Resolve when the media has been starting playing.
+ */
+function checkOrWaitUntilMediaStartedPlaying(tab, elementId) {
+  return SpecialPowers.spawn(tab.linkedBrowser, [elementId], Id => {
+    return new Promise(resolve => {
+      const video = content.document.getElementById(Id);
+      if (!video) {
+        ok(false, `can't get the media element!`);
+      }
+      if (!video.paused) {
+        ok(true, `media started playing`);
+        resolve();
+      } else {
+        info(`wait until media starts playing`);
+        video.onplaying = () => {
+          video.onplaying = null;
+          ok(true, `media started playing`);
+          resolve();
+        };
+      }
+    });
+  });
+}
+
+/**
+ * Returns a promise that resolves when the specific media stops playing.
+ *
+ * @param {tab} tab
+ *        The tab that contains the media which we would check
+ * @param {string} elementId
+ *        The element Id of the media which we would check
+ * @return {Promise}
+ *         Resolve when the media has been stopped playing.
+ */
+function checkOrWaitUntilMediaStoppedPlaying(tab, elementId) {
+  return SpecialPowers.spawn(tab.linkedBrowser, [elementId], Id => {
+    return new Promise(resolve => {
+      const video = content.document.getElementById(Id);
+      if (!video) {
+        ok(false, `can't get the media element!`);
+      }
+      if (video.paused) {
+        ok(true, `media stopped playing`);
+        resolve();
+      } else {
+        info(`wait until media stops playing`);
+        video.onpause = () => {
+          video.onpause = null;
+          ok(true, `media stopped playing`);
+          resolve();
+        };
+      }
+    });
+  });
+}
+
+/**
+ * Check if the active metadata is empty.
+ */
+function isCurrentMetadataEmpty() {
+  const current = MediaControlService.getCurrentActiveMediaMetadata();
+  is(current.title, "", `current title should be empty`);
+  is(current.artist, "", `current title should be empty`);
+  is(current.album, "", `current album should be empty`);
+  is(current.artwork.length, 0, `current artwork should be empty`);
+}
+
+/**
+ * Check if the active metadata is equal to the given metadata.artwork
+ *
+ * @param {object} metadata
+ *        The metadata that would be compared with the active metadata
+ */
+function isCurrentMetadataEqualTo(metadata) {
+  const current = MediaControlService.getCurrentActiveMediaMetadata();
+  is(
+    current.title,
+    metadata.title,
+    `tile '${current.title}' is equal to ${metadata.title}`
+  );
+  is(
+    current.artist,
+    metadata.artist,
+    `artist '${current.artist}' is equal to ${metadata.artist}`
+  );
+  is(
+    current.album,
+    metadata.album,
+    `album '${current.album}' is equal to ${metadata.album}`
+  );
+  is(
+    current.artwork.length,
+    metadata.artwork.length,
+    `artwork length '${current.artwork.length}' is equal to ${metadata.artwork.length}`
+  );
+  for (let idx = 0; idx < metadata.artwork.length; idx++) {
+    // the current src we got would be a completed path of the image, so we do
+    // not check if they are equal, we check if the current src includes the
+    // metadata's file name. Eg. "http://foo/bar.jpg" v.s. "bar.jpg"
+    ok(
+      current.artwork[idx].src.includes(metadata.artwork[idx].src),
+      `artwork src '${current.artwork[idx].src}' includes ${metadata.artwork[idx].src}`
+    );
+    is(
+      current.artwork[idx].sizes,
+      metadata.artwork[idx].sizes,
+      `artwork sizes '${current.artwork[idx].sizes}' is equal to ${metadata.artwork[idx].sizes}`
+    );
+    is(
+      current.artwork[idx].type,
+      metadata.artwork[idx].type,
+      `artwork type '${current.artwork[idx].type}' is equal to ${metadata.artwork[idx].type}`
+    );
+  }
+}
+
+/**
+ * Check if the given tab is using the default metadata. If the tab is being
+ * used in the private browsing mode, `isPrivateBrowsing` should be definded in
+ * the `options`.
+ */
+async function isGivenTabUsingDefaultMetadata(tab, options = {}) {
+  const localization = new Localization([
+    "branding/brand.ftl",
+    "dom/media.ftl",
+  ]);
+  const fallbackTitle = await localization.formatValue(
+    "mediastatus-fallback-title"
+  );
+  ok(fallbackTitle.length, "l10n fallback title is not empty");
+
+  const metadata =
+    tab.linkedBrowser.browsingContext.mediaController.getMetadata();
+
+  await SpecialPowers.spawn(
+    tab.linkedBrowser,
+    [metadata.title, fallbackTitle, options.isPrivateBrowsing],
+    (title, fallbackTitle, isPrivateBrowsing) => {
+      if (isPrivateBrowsing || !content.document.title.length) {
+        is(title, fallbackTitle, "Using a generic default fallback title");
+      } else {
+        is(
+          title,
+          content.document.title,
+          "Using website title as a default title"
+        );
+      }
+    }
+  );
+  is(metadata.artwork.length, 1, "Default metada contains one artwork");
+  ok(
+    metadata.artwork[0].src.includes("defaultFavicon.svg"),
+    "Using default favicon as a default art work"
+  );
+}
+
+/**
+ * Wait until the main media controller changes its playback state, we would
+ * observe that by listening for `media-displayed-playback-changed`
+ * notification.
+ *
+ * @return {Promise}
+ *         Resolve when observing `media-displayed-playback-changed`
+ */
+function waitUntilDisplayedPlaybackChanged() {
+  return BrowserUtils.promiseObserved("media-displayed-playback-changed");
+}
+
+/**
+ * Wait until the metadata that would be displayed on the virtual control
+ * interface changes. we would observe that by listening for
+ * `media-displayed-metadata-changed` notification.
+ *
+ * @return {Promise}
+ *         Resolve when observing `media-displayed-metadata-changed`
+ */
+function waitUntilDisplayedMetadataChanged() {
+  return BrowserUtils.promiseObserved("media-displayed-metadata-changed");
+}
+
+/**
+ * Wait until the main media controller has been changed, we would observe that
+ * by listening for the `main-media-controller-changed` notification.
+ *
+ * @return {Promise}
+ *         Resolve when observing `main-media-controller-changed`
+ */
+function waitUntilMainMediaControllerChanged() {
+  return BrowserUtils.promiseObserved("main-media-controller-changed");
+}
+
+/**
+ * Wait until any media controller updates its metadata even if it's not the
+ * main controller. The difference between this function and
+ * `waitUntilDisplayedMetadataChanged()` is that the changed metadata might come
+ * from non-main controller so it won't be show on the virtual control
+ * interface. we would observe that by listening for
+ * `media-session-controller-metadata-changed` notification.
+ *
+ * @return {Promise}
+ *         Resolve when observing `media-session-controller-metadata-changed`
+ */
+function waitUntilControllerMetadataChanged() {
+  return BrowserUtils.promiseObserved(
+    "media-session-controller-metadata-changed"
+  );
+}
+
+/**
+ * Wait until media controller amount changes, we would observe that by
+ * listening for `media-controller-amount-changed` notification.
+ *
+ * @return {Promise}
+ *         Resolve when observing `media-controller-amount-changed`
+ */
+function waitUntilMediaControllerAmountChanged() {
+  return BrowserUtils.promiseObserved("media-controller-amount-changed");
+}
+
+/**
+ * check if the media controll from given tab is active. If not, return a
+ * promise and resolve it when controller become active.
+ */
+async function checkOrWaitUntilControllerBecomeActive(tab) {
+  const controller = tab.linkedBrowser.browsingContext.mediaController;
+  if (controller.isActive) {
+    return;
+  }
+  await new Promise(r => (controller.onactivated = r));
+}
diff --git a/dom/media/mediacontrol/tests/gtest/MediaKeyListenerTest.h b/dom/media/mediacontrol/tests/gtest/MediaKeyListenerTest.h
new file mode 100644
index 0000000000..5145eb7dbb
--- /dev/null
+++ b/dom/media/mediacontrol/tests/gtest/MediaKeyListenerTest.h
@@ -0,0 +1,39 @@
+/* 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 DOM_MEDIA_MEDIAKEYLISTENERTEST_H_
+#define DOM_MEDIA_MEDIAKEYLISTENERTEST_H_
+
+#include "MediaControlKeySource.h"
+#include "mozilla/Maybe.h"
+
+namespace mozilla {
+namespace dom {
+
+class MediaKeyListenerTest : public MediaControlKeyListener {
+ public:
+  NS_INLINE_DECL_REFCOUNTING(MediaKeyListenerTest, override)
+
+  void Clear() { mReceivedKey = mozilla::Nothing(); }
+
+  void OnActionPerformed(const MediaControlAction& aAction) override {
+    mReceivedKey = mozilla::Some(aAction.mKey);
+  }
+  bool IsResultEqualTo(MediaControlKey aResult) const {
+    if (mReceivedKey) {
+      return *mReceivedKey == aResult;
+    }
+    return false;
+  }
+  bool IsReceivedResult() const { return mReceivedKey.isSome(); }
+
+ private:
+  ~MediaKeyListenerTest() = default;
+  mozilla::Maybe<MediaControlKey> mReceivedKey;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // DOM_MEDIA_MEDIAKEYLISTENERTEST_H_
diff --git a/dom/media/mediacontrol/tests/gtest/TestAudioFocusManager.cpp b/dom/media/mediacontrol/tests/gtest/TestAudioFocusManager.cpp
new file mode 100644
index 0000000000..df1bb288a4
--- /dev/null
+++ b/dom/media/mediacontrol/tests/gtest/TestAudioFocusManager.cpp
@@ -0,0 +1,163 @@
+/* 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/. */
+
+#include "gtest/gtest.h"
+#include "AudioFocusManager.h"
+#include "MediaControlService.h"
+#include "mozilla/Preferences.h"
+
+using namespace mozilla::dom;
+
+#define FIRST_CONTROLLER_ID 0
+#define SECOND_CONTROLLER_ID 1
+
+// This RAII class is used to set the audio focus management pref within a test
+// and automatically revert the change when a test ends, in order not to
+// interfere other tests unexpectedly.
+class AudioFocusManagmentPrefSetterRAII {
+ public:
+  explicit AudioFocusManagmentPrefSetterRAII(bool aPrefValue) {
+    mOriginalValue = mozilla::Preferences::GetBool(mPrefName, false);
+    mozilla::Preferences::SetBool(mPrefName, aPrefValue);
+  }
+  ~AudioFocusManagmentPrefSetterRAII() {
+    mozilla::Preferences::SetBool(mPrefName, mOriginalValue);
+  }
+
+ private:
+  const char* mPrefName = "media.audioFocus.management";
+  bool mOriginalValue;
+};
+
+TEST(AudioFocusManager, TestRequestAudioFocus)
+{
+  AudioFocusManager manager;
+  ASSERT_TRUE(manager.GetAudioFocusNums() == 0);
+
+  RefPtr<MediaController> controller = new MediaController(FIRST_CONTROLLER_ID);
+
+  manager.RequestAudioFocus(controller);
+  ASSERT_TRUE(manager.GetAudioFocusNums() == 1);
+
+  manager.RevokeAudioFocus(controller);
+  ASSERT_TRUE(manager.GetAudioFocusNums() == 0);
+}
+
+TEST(AudioFocusManager, TestAudioFocusNumsWhenEnableAudioFocusManagement)
+{
+  // When enabling audio focus management, we only allow one controller owing
+  // audio focus at a time when the audio competing occurs. As the mechanism of
+  // handling the audio competing involves multiple components, we can't test it
+  // simply by using the APIs from AudioFocusManager.
+  AudioFocusManagmentPrefSetterRAII prefSetter(true);
+
+  AudioFocusManager manager;
+  ASSERT_TRUE(manager.GetAudioFocusNums() == 0);
+
+  RefPtr<MediaController> controller1 =
+      new MediaController(FIRST_CONTROLLER_ID);
+
+  RefPtr<MediaController> controller2 =
+      new MediaController(SECOND_CONTROLLER_ID);
+
+  manager.RequestAudioFocus(controller1);
+  ASSERT_TRUE(manager.GetAudioFocusNums() == 1);
+
+  // When controller2 starts, it would win the audio focus from controller1. So
+  // only one audio focus would exist.
+  manager.RequestAudioFocus(controller2);
+  ASSERT_TRUE(manager.GetAudioFocusNums() == 1);
+
+  manager.RevokeAudioFocus(controller2);
+  ASSERT_TRUE(manager.GetAudioFocusNums() == 0);
+}
+
+TEST(AudioFocusManager, TestAudioFocusNumsWhenDisableAudioFocusManagement)
+{
+  // When disabling audio focus management, we won't handle the audio competing,
+  // so we allow multiple audio focus existing at the same time.
+  AudioFocusManagmentPrefSetterRAII prefSetter(false);
+
+  AudioFocusManager manager;
+  ASSERT_TRUE(manager.GetAudioFocusNums() == 0);
+
+  RefPtr<MediaController> controller1 =
+      new MediaController(FIRST_CONTROLLER_ID);
+
+  RefPtr<MediaController> controller2 =
+      new MediaController(SECOND_CONTROLLER_ID);
+
+  manager.RequestAudioFocus(controller1);
+  ASSERT_TRUE(manager.GetAudioFocusNums() == 1);
+
+  manager.RequestAudioFocus(controller2);
+  ASSERT_TRUE(manager.GetAudioFocusNums() == 2);
+
+  manager.RevokeAudioFocus(controller1);
+  ASSERT_TRUE(manager.GetAudioFocusNums() == 1);
+
+  manager.RevokeAudioFocus(controller2);
+  ASSERT_TRUE(manager.GetAudioFocusNums() == 0);
+}
+
+TEST(AudioFocusManager, TestRequestAudioFocusRepeatedly)
+{
+  AudioFocusManager manager;
+  ASSERT_TRUE(manager.GetAudioFocusNums() == 0);
+
+  RefPtr<MediaController> controller = new MediaController(FIRST_CONTROLLER_ID);
+
+  manager.RequestAudioFocus(controller);
+  ASSERT_TRUE(manager.GetAudioFocusNums() == 1);
+
+  manager.RequestAudioFocus(controller);
+  ASSERT_TRUE(manager.GetAudioFocusNums() == 1);
+}
+
+TEST(AudioFocusManager, TestRevokeAudioFocusRepeatedly)
+{
+  AudioFocusManager manager;
+  ASSERT_TRUE(manager.GetAudioFocusNums() == 0);
+
+  RefPtr<MediaController> controller = new MediaController(FIRST_CONTROLLER_ID);
+
+  manager.RequestAudioFocus(controller);
+  ASSERT_TRUE(manager.GetAudioFocusNums() == 1);
+
+  manager.RevokeAudioFocus(controller);
+  ASSERT_TRUE(manager.GetAudioFocusNums() == 0);
+
+  manager.RevokeAudioFocus(controller);
+  ASSERT_TRUE(manager.GetAudioFocusNums() == 0);
+}
+
+TEST(AudioFocusManager, TestRevokeAudioFocusWithoutRequestAudioFocus)
+{
+  AudioFocusManager manager;
+  ASSERT_TRUE(manager.GetAudioFocusNums() == 0);
+
+  RefPtr<MediaController> controller = new MediaController(FIRST_CONTROLLER_ID);
+
+  manager.RevokeAudioFocus(controller);
+  ASSERT_TRUE(manager.GetAudioFocusNums() == 0);
+}
+
+TEST(AudioFocusManager,
+     TestRevokeAudioFocusForControllerWithoutOwningAudioFocus)
+{
+  AudioFocusManager manager;
+  ASSERT_TRUE(manager.GetAudioFocusNums() == 0);
+
+  RefPtr<MediaController> controller1 =
+      new MediaController(FIRST_CONTROLLER_ID);
+
+  RefPtr<MediaController> controller2 =
+      new MediaController(SECOND_CONTROLLER_ID);
+
+  manager.RequestAudioFocus(controller1);
+  ASSERT_TRUE(manager.GetAudioFocusNums() == 1);
+
+  manager.RevokeAudioFocus(controller2);
+  ASSERT_TRUE(manager.GetAudioFocusNums() == 1);
+}
diff --git a/dom/media/mediacontrol/tests/gtest/TestMediaControlService.cpp b/dom/media/mediacontrol/tests/gtest/TestMediaControlService.cpp
new file mode 100644
index 0000000000..ab5b0cb8c7
--- /dev/null
+++ b/dom/media/mediacontrol/tests/gtest/TestMediaControlService.cpp
@@ -0,0 +1,64 @@
+/* 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/. */
+
+#include "gtest/gtest.h"
+#include "MediaControlService.h"
+#include "MediaController.h"
+
+using namespace mozilla::dom;
+
+#define FIRST_CONTROLLER_ID 0
+#define SECOND_CONTROLLER_ID 1
+
+TEST(MediaControlService, TestAddOrRemoveControllers)
+{
+  RefPtr<MediaControlService> service = MediaControlService::GetService();
+  ASSERT_TRUE(service->GetActiveControllersNum() == 0);
+
+  RefPtr<MediaController> controller1 =
+      new MediaController(FIRST_CONTROLLER_ID);
+  RefPtr<MediaController> controller2 =
+      new MediaController(SECOND_CONTROLLER_ID);
+
+  service->RegisterActiveMediaController(controller1);
+  ASSERT_TRUE(service->GetActiveControllersNum() == 1);
+
+  service->RegisterActiveMediaController(controller2);
+  ASSERT_TRUE(service->GetActiveControllersNum() == 2);
+
+  service->UnregisterActiveMediaController(controller1);
+  ASSERT_TRUE(service->GetActiveControllersNum() == 1);
+
+  service->UnregisterActiveMediaController(controller2);
+  ASSERT_TRUE(service->GetActiveControllersNum() == 0);
+}
+
+TEST(MediaControlService, TestMainController)
+{
+  RefPtr<MediaControlService> service = MediaControlService::GetService();
+  ASSERT_TRUE(service->GetActiveControllersNum() == 0);
+
+  RefPtr<MediaController> controller1 =
+      new MediaController(FIRST_CONTROLLER_ID);
+  service->RegisterActiveMediaController(controller1);
+
+  RefPtr<MediaController> mainController = service->GetMainController();
+  ASSERT_TRUE(mainController->Id() == FIRST_CONTROLLER_ID);
+
+  RefPtr<MediaController> controller2 =
+      new MediaController(SECOND_CONTROLLER_ID);
+  service->RegisterActiveMediaController(controller2);
+
+  mainController = service->GetMainController();
+  ASSERT_TRUE(mainController->Id() == SECOND_CONTROLLER_ID);
+
+  service->UnregisterActiveMediaController(controller2);
+  mainController = service->GetMainController();
+  ASSERT_TRUE(mainController->Id() == FIRST_CONTROLLER_ID);
+
+  service->UnregisterActiveMediaController(controller1);
+  mainController = service->GetMainController();
+  ASSERT_TRUE(service->GetActiveControllersNum() == 0);
+  ASSERT_TRUE(!mainController);
+}
diff --git a/dom/media/mediacontrol/tests/gtest/TestMediaController.cpp b/dom/media/mediacontrol/tests/gtest/TestMediaController.cpp
new file mode 100644
index 0000000000..5ba8d2a7d5
--- /dev/null
+++ b/dom/media/mediacontrol/tests/gtest/TestMediaController.cpp
@@ -0,0 +1,204 @@
+/* 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/. */
+
+#include "gtest/gtest.h"
+#include "MediaControlService.h"
+#include "MediaController.h"
+#include "mozilla/dom/MediaSessionBinding.h"
+
+using namespace mozilla::dom;
+
+#define CONTROLLER_ID 0
+#define FAKE_CONTEXT_ID 0
+
+#define FIRST_CONTROLLER_ID 0
+
+TEST(MediaController, DefaultValueCheck)
+{
+  RefPtr<MediaController> controller = new MediaController(CONTROLLER_ID);
+  ASSERT_TRUE(!controller->IsAnyMediaBeingControlled());
+  ASSERT_TRUE(controller->Id() == CONTROLLER_ID);
+  ASSERT_TRUE(controller->PlaybackState() == MediaSessionPlaybackState::None);
+  ASSERT_TRUE(!controller->IsAudible());
+}
+
+TEST(MediaController, IsAnyMediaBeingControlled)
+{
+  RefPtr<MediaController> controller = new MediaController(CONTROLLER_ID);
+  ASSERT_TRUE(!controller->IsAnyMediaBeingControlled());
+
+  controller->NotifyMediaPlaybackChanged(FAKE_CONTEXT_ID,
+                                         MediaPlaybackState::eStarted);
+  ASSERT_TRUE(controller->IsAnyMediaBeingControlled());
+
+  controller->NotifyMediaPlaybackChanged(FAKE_CONTEXT_ID,
+                                         MediaPlaybackState::eStarted);
+  ASSERT_TRUE(controller->IsAnyMediaBeingControlled());
+
+  controller->NotifyMediaPlaybackChanged(FAKE_CONTEXT_ID,
+                                         MediaPlaybackState::eStopped);
+  ASSERT_TRUE(controller->IsAnyMediaBeingControlled());
+
+  controller->NotifyMediaPlaybackChanged(FAKE_CONTEXT_ID,
+                                         MediaPlaybackState::eStopped);
+  ASSERT_TRUE(!controller->IsAnyMediaBeingControlled());
+}
+
+class FakeControlledMedia final {
+ public:
+  explicit FakeControlledMedia(MediaController* aController)
+      : mController(aController) {
+    mController->NotifyMediaPlaybackChanged(FAKE_CONTEXT_ID,
+                                            MediaPlaybackState::eStarted);
+  }
+
+  void SetPlaying(MediaPlaybackState aState) {
+    if (mPlaybackState == aState) {
+      return;
+    }
+    mController->NotifyMediaPlaybackChanged(FAKE_CONTEXT_ID, aState);
+    mPlaybackState = aState;
+  }
+
+  void SetAudible(MediaAudibleState aState) {
+    if (mAudibleState == aState) {
+      return;
+    }
+    mController->NotifyMediaAudibleChanged(FAKE_CONTEXT_ID, aState);
+    mAudibleState = aState;
+  }
+
+  ~FakeControlledMedia() {
+    if (mPlaybackState == MediaPlaybackState::ePlayed) {
+      mController->NotifyMediaPlaybackChanged(FAKE_CONTEXT_ID,
+                                              MediaPlaybackState::ePaused);
+    }
+    mController->NotifyMediaPlaybackChanged(FAKE_CONTEXT_ID,
+                                            MediaPlaybackState::eStopped);
+  }
+
+ private:
+  MediaPlaybackState mPlaybackState = MediaPlaybackState::eStopped;
+  MediaAudibleState mAudibleState = MediaAudibleState::eInaudible;
+  RefPtr<MediaController> mController;
+};
+
+TEST(MediaController, ActiveAndDeactiveController)
+{
+  RefPtr<MediaControlService> service = MediaControlService::GetService();
+  ASSERT_TRUE(service->GetActiveControllersNum() == 0);
+
+  RefPtr<MediaController> controller = new MediaController(FIRST_CONTROLLER_ID);
+
+  // In order to check active control number after FakeControlledMedia
+  // destroyed.
+  {
+    FakeControlledMedia fakeMedia(controller);
+    fakeMedia.SetPlaying(MediaPlaybackState::ePlayed);
+    ASSERT_TRUE(service->GetActiveControllersNum() == 1);
+
+    fakeMedia.SetAudible(MediaAudibleState::eAudible);
+    ASSERT_TRUE(service->GetActiveControllersNum() == 1);
+
+    fakeMedia.SetAudible(MediaAudibleState::eInaudible);
+    ASSERT_TRUE(service->GetActiveControllersNum() == 1);
+  }
+
+  ASSERT_TRUE(service->GetActiveControllersNum() == 0);
+}
+
+TEST(MediaController, AudibleChanged)
+{
+  RefPtr<MediaController> controller = new MediaController(CONTROLLER_ID);
+
+  FakeControlledMedia fakeMedia(controller);
+  fakeMedia.SetPlaying(MediaPlaybackState::ePlayed);
+  ASSERT_TRUE(!controller->IsAudible());
+
+  fakeMedia.SetAudible(MediaAudibleState::eAudible);
+  ASSERT_TRUE(controller->IsAudible());
+
+  fakeMedia.SetAudible(MediaAudibleState::eInaudible);
+  ASSERT_TRUE(!controller->IsAudible());
+}
+
+TEST(MediaController, PlayingStateChangeViaControlledMedia)
+{
+  RefPtr<MediaController> controller = new MediaController(CONTROLLER_ID);
+
+  // In order to check playing state after FakeControlledMedia destroyed.
+  {
+    FakeControlledMedia foo(controller);
+    ASSERT_TRUE(controller->PlaybackState() == MediaSessionPlaybackState::None);
+
+    foo.SetPlaying(MediaPlaybackState::ePlayed);
+    ASSERT_TRUE(controller->PlaybackState() ==
+                MediaSessionPlaybackState::Playing);
+
+    foo.SetPlaying(MediaPlaybackState::ePaused);
+    ASSERT_TRUE(controller->PlaybackState() ==
+                MediaSessionPlaybackState::Paused);
+
+    foo.SetPlaying(MediaPlaybackState::ePlayed);
+    ASSERT_TRUE(controller->PlaybackState() ==
+                MediaSessionPlaybackState::Playing);
+  }
+
+  // FakeControlledMedia has been destroyed, no playing media exists.
+  ASSERT_TRUE(controller->PlaybackState() == MediaSessionPlaybackState::Paused);
+}
+
+TEST(MediaController, ControllerShouldRemainPlayingIfAnyPlayingMediaExists)
+{
+  RefPtr<MediaController> controller = new MediaController(CONTROLLER_ID);
+
+  {
+    FakeControlledMedia foo(controller);
+    ASSERT_TRUE(controller->PlaybackState() == MediaSessionPlaybackState::None);
+
+    foo.SetPlaying(MediaPlaybackState::ePlayed);
+    ASSERT_TRUE(controller->PlaybackState() ==
+                MediaSessionPlaybackState::Playing);
+
+    // foo is playing, so controller is in `playing` state.
+    FakeControlledMedia bar(controller);
+    ASSERT_TRUE(controller->PlaybackState() ==
+                MediaSessionPlaybackState::Playing);
+
+    bar.SetPlaying(MediaPlaybackState::ePlayed);
+    ASSERT_TRUE(controller->PlaybackState() ==
+                MediaSessionPlaybackState::Playing);
+
+    // Although we paused bar, but foo is still playing, so the controller would
+    // still be in `playing`.
+    bar.SetPlaying(MediaPlaybackState::ePaused);
+    ASSERT_TRUE(controller->PlaybackState() ==
+                MediaSessionPlaybackState::Playing);
+
+    foo.SetPlaying(MediaPlaybackState::ePaused);
+    ASSERT_TRUE(controller->PlaybackState() ==
+                MediaSessionPlaybackState::Paused);
+  }
+
+  // both foo and bar have been destroyed, no playing media exists.
+  ASSERT_TRUE(controller->PlaybackState() == MediaSessionPlaybackState::Paused);
+}
+
+TEST(MediaController, PictureInPictureModeOrFullscreen)
+{
+  RefPtr<MediaController> controller = new MediaController(CONTROLLER_ID);
+  ASSERT_TRUE(!controller->IsBeingUsedInPIPModeOrFullscreen());
+
+  controller->SetIsInPictureInPictureMode(FAKE_CONTEXT_ID, true);
+  ASSERT_TRUE(controller->IsBeingUsedInPIPModeOrFullscreen());
+
+  controller->SetIsInPictureInPictureMode(FAKE_CONTEXT_ID, false);
+  ASSERT_TRUE(!controller->IsBeingUsedInPIPModeOrFullscreen());
+
+  controller->NotifyMediaFullScreenState(FAKE_CONTEXT_ID, true);
+  ASSERT_TRUE(controller->IsBeingUsedInPIPModeOrFullscreen());
+
+  controller->NotifyMediaFullScreenState(FAKE_CONTEXT_ID, false);
+  ASSERT_TRUE(!controller->IsBeingUsedInPIPModeOrFullscreen());
+}
diff --git a/dom/media/mediacontrol/tests/gtest/TestMediaKeysEvent.cpp b/dom/media/mediacontrol/tests/gtest/TestMediaKeysEvent.cpp
new file mode 100644
index 0000000000..a73ceb8592
--- /dev/null
+++ b/dom/media/mediacontrol/tests/gtest/TestMediaKeysEvent.cpp
@@ -0,0 +1,49 @@
+/* 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/. */
+
+#include "gtest/gtest.h"
+#include "MediaController.h"
+#include "MediaControlKeySource.h"
+
+using namespace mozilla::dom;
+
+class MediaControlKeySourceTestImpl : public MediaControlKeySource {
+ public:
+  NS_INLINE_DECL_REFCOUNTING(MediaControlKeySourceTestImpl, override)
+  bool Open() override { return true; }
+  bool IsOpened() const override { return true; }
+  void SetSupportedMediaKeys(const MediaKeysArray& aSupportedKeys) override {}
+
+ private:
+  ~MediaControlKeySourceTestImpl() = default;
+};
+
+TEST(MediaControlKey, TestAddOrRemoveListener)
+{
+  RefPtr<MediaControlKeySource> source = new MediaControlKeySourceTestImpl();
+  ASSERT_TRUE(source->GetListenersNum() == 0);
+
+  RefPtr<MediaControlKeyListener> listener = new MediaControlKeyHandler();
+
+  source->AddListener(listener);
+  ASSERT_TRUE(source->GetListenersNum() == 1);
+
+  source->RemoveListener(listener);
+  ASSERT_TRUE(source->GetListenersNum() == 0);
+}
+
+TEST(MediaControlKey, SetSourcePlaybackState)
+{
+  RefPtr<MediaControlKeySource> source = new MediaControlKeySourceTestImpl();
+  ASSERT_TRUE(source->GetPlaybackState() == MediaSessionPlaybackState::None);
+
+  source->SetPlaybackState(MediaSessionPlaybackState::Playing);
+  ASSERT_TRUE(source->GetPlaybackState() == MediaSessionPlaybackState::Playing);
+
+  source->SetPlaybackState(MediaSessionPlaybackState::Paused);
+  ASSERT_TRUE(source->GetPlaybackState() == MediaSessionPlaybackState::Paused);
+
+  source->SetPlaybackState(MediaSessionPlaybackState::None);
+  ASSERT_TRUE(source->GetPlaybackState() == MediaSessionPlaybackState::None);
+}
diff --git a/dom/media/mediacontrol/tests/gtest/TestMediaKeysEventMac.mm b/dom/media/mediacontrol/tests/gtest/TestMediaKeysEventMac.mm
new file mode 100644
index 0000000000..3c8ce8cd9e
--- /dev/null
+++ b/dom/media/mediacontrol/tests/gtest/TestMediaKeysEventMac.mm
@@ -0,0 +1,136 @@
+/* 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/. */
+
+#import <AppKit/AppKit.h>
+#import <AppKit/NSEvent.h>
+#import <ApplicationServices/ApplicationServices.h>
+#import <CoreFoundation/CoreFoundation.h>
+#import <IOKit/hidsystem/ev_keymap.h>
+
+#include "gtest/gtest.h"
+#include "MediaHardwareKeysEventSourceMac.h"
+#include "MediaKeyListenerTest.h"
+#include "mozilla/Maybe.h"
+
+using namespace mozilla::dom;
+using namespace mozilla::widget;
+
+static const int kSystemDefinedEventMediaKeysSubtype = 8;
+
+static void SendFakeEvent(RefPtr<MediaHardwareKeysEventSourceMac>& aSource, int aKeyData) {
+  NSEvent* event = [NSEvent otherEventWithType:NSEventTypeSystemDefined
+                                      location:NSZeroPoint
+                                 modifierFlags:0
+                                     timestamp:0
+                                  windowNumber:0
+                                       context:nil
+                                       subtype:kSystemDefinedEventMediaKeysSubtype
+                                         data1:aKeyData
+                                         data2:0];
+  aSource->EventTapCallback(nullptr, static_cast<CGEventType>(0), [event CGEvent], aSource.get());
+}
+
+static void NotifyFakeNonMediaKey(RefPtr<MediaHardwareKeysEventSourceMac>& aSource,
+                                  bool aIsKeyPressed) {
+  int keyData = 0 | ((aIsKeyPressed ? 0xA : 0xB) << 8);
+  SendFakeEvent(aSource, keyData);
+}
+
+static void NotifyFakeMediaControlKey(RefPtr<MediaHardwareKeysEventSourceMac>& aSource,
+                                      MediaControlKey aEvent, bool aIsKeyPressed) {
+  int keyData = 0;
+  if (aEvent == MediaControlKey::Playpause) {
+    keyData = NX_KEYTYPE_PLAY << 16;
+  } else if (aEvent == MediaControlKey::Nexttrack) {
+    keyData = NX_KEYTYPE_NEXT << 16;
+  } else if (aEvent == MediaControlKey::Previoustrack) {
+    keyData = NX_KEYTYPE_PREVIOUS << 16;
+  }
+  keyData |= ((aIsKeyPressed ? 0xA : 0xB) << 8);
+  SendFakeEvent(aSource, keyData);
+}
+
+static void NotifyKeyPressedMediaKey(RefPtr<MediaHardwareKeysEventSourceMac>& aSource,
+                                     MediaControlKey aEvent) {
+  NotifyFakeMediaControlKey(aSource, aEvent, true /* key pressed */);
+}
+
+static void NotifyKeyReleasedMediaKeysEvent(RefPtr<MediaHardwareKeysEventSourceMac>& aSource,
+                                            MediaControlKey aEvent) {
+  NotifyFakeMediaControlKey(aSource, aEvent, false /* key released */);
+}
+
+static void NotifyKeyPressedNonMediaKeysEvents(RefPtr<MediaHardwareKeysEventSourceMac>& aSource) {
+  NotifyFakeNonMediaKey(aSource, true /* key pressed */);
+}
+
+static void NotifyKeyReleasedNonMediaKeysEvents(RefPtr<MediaHardwareKeysEventSourceMac>& aSource) {
+  NotifyFakeNonMediaKey(aSource, false /* key released */);
+}
+
+TEST(MediaHardwareKeysEventSourceMac, TestKeyPressedMediaKeysEvent)
+{
+  RefPtr<MediaHardwareKeysEventSourceMac> source = new MediaHardwareKeysEventSourceMac();
+  ASSERT_TRUE(source->GetListenersNum() == 0);
+
+  RefPtr<MediaKeyListenerTest> listener = new MediaKeyListenerTest();
+  source->AddListener(listener.get());
+  ASSERT_TRUE(source->GetListenersNum() == 1);
+  ASSERT_TRUE(!listener->IsReceivedResult());
+
+  NotifyKeyPressedMediaKey(source, MediaControlKey::Playpause);
+  ASSERT_TRUE(listener->IsResultEqualTo(MediaControlKey::Playpause));
+
+  NotifyKeyPressedMediaKey(source, MediaControlKey::Nexttrack);
+  ASSERT_TRUE(listener->IsResultEqualTo(MediaControlKey::Nexttrack));
+
+  NotifyKeyPressedMediaKey(source, MediaControlKey::Previoustrack);
+  ASSERT_TRUE(listener->IsResultEqualTo(MediaControlKey::Previoustrack));
+
+  source->RemoveListener(listener);
+  ASSERT_TRUE(source->GetListenersNum() == 0);
+}
+
+TEST(MediaHardwareKeysEventSourceMac, TestKeyReleasedMediaKeysEvent)
+{
+  RefPtr<MediaHardwareKeysEventSourceMac> source = new MediaHardwareKeysEventSourceMac();
+  ASSERT_TRUE(source->GetListenersNum() == 0);
+
+  RefPtr<MediaKeyListenerTest> listener = new MediaKeyListenerTest();
+  source->AddListener(listener.get());
+  ASSERT_TRUE(source->GetListenersNum() == 1);
+  ASSERT_TRUE(!listener->IsReceivedResult());
+
+  NotifyKeyReleasedMediaKeysEvent(source, MediaControlKey::Playpause);
+  ASSERT_TRUE(!listener->IsReceivedResult());
+
+  NotifyKeyReleasedMediaKeysEvent(source, MediaControlKey::Nexttrack);
+  ASSERT_TRUE(!listener->IsReceivedResult());
+
+  NotifyKeyReleasedMediaKeysEvent(source, MediaControlKey::Previoustrack);
+  ASSERT_TRUE(!listener->IsReceivedResult());
+
+  source->RemoveListener(listener);
+  ASSERT_TRUE(source->GetListenersNum() == 0);
+}
+
+TEST(MediaHardwareKeysEventSourceMac, TestNonMediaKeysEvent)
+{
+  RefPtr<MediaHardwareKeysEventSourceMac> source = new MediaHardwareKeysEventSourceMac();
+  ASSERT_TRUE(source->GetListenersNum() == 0);
+
+  RefPtr<MediaKeyListenerTest> listener = new MediaKeyListenerTest();
+  source->AddListener(listener.get());
+  ASSERT_TRUE(source->GetListenersNum() == 1);
+  ASSERT_TRUE(!listener->IsReceivedResult());
+
+  NotifyKeyPressedNonMediaKeysEvents(source);
+  ASSERT_TRUE(!listener->IsReceivedResult());
+
+  NotifyKeyReleasedNonMediaKeysEvents(source);
+  ASSERT_TRUE(!listener->IsReceivedResult());
+
+  source->RemoveListener(listener);
+  ASSERT_TRUE(source->GetListenersNum() == 0);
+}
diff --git a/dom/media/mediacontrol/tests/gtest/TestMediaKeysEventMediaCenter.mm b/dom/media/mediacontrol/tests/gtest/TestMediaKeysEventMediaCenter.mm
new file mode 100644
index 0000000000..1d32960d2f
--- /dev/null
+++ b/dom/media/mediacontrol/tests/gtest/TestMediaKeysEventMediaCenter.mm
@@ -0,0 +1,166 @@
+/* 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/. */
+#import <MediaPlayer/MediaPlayer.h>
+
+#include "gtest/gtest.h"
+#include "MediaHardwareKeysEventSourceMacMediaCenter.h"
+#include "MediaKeyListenerTest.h"
+#include "nsCocoaFeatures.h"
+#include "nsCocoaUtils.h"
+#include "prinrval.h"
+#include "prthread.h"
+
+using namespace mozilla::dom;
+using namespace mozilla::widget;
+
+NS_ASSUME_NONNULL_BEGIN
+
+TEST(MediaHardwareKeysEventSourceMacMediaCenter, TestMediaCenterPlayPauseEvent)
+{
+  RefPtr<MediaHardwareKeysEventSourceMacMediaCenter> source =
+      new MediaHardwareKeysEventSourceMacMediaCenter();
+
+  ASSERT_TRUE(source->GetListenersNum() == 0);
+
+  RefPtr<MediaKeyListenerTest> listener = new MediaKeyListenerTest();
+
+  MPNowPlayingInfoCenter* center = [MPNowPlayingInfoCenter defaultCenter];
+
+  source->AddListener(listener.get());
+
+  ASSERT_TRUE(source->Open());
+
+  ASSERT_TRUE(source->GetListenersNum() == 1);
+  ASSERT_TRUE(!listener->IsReceivedResult());
+  ASSERT_TRUE(center.playbackState == MPNowPlayingPlaybackStatePlaying);
+
+  MediaCenterEventHandler playPauseHandler = source->CreatePlayPauseHandler();
+  playPauseHandler(nil);
+
+  ASSERT_TRUE(center.playbackState == MPNowPlayingPlaybackStatePaused);
+  ASSERT_TRUE(listener->IsResultEqualTo(MediaControlKey::Playpause));
+
+  listener->Clear();  // Reset stored media key
+
+  playPauseHandler(nil);
+
+  ASSERT_TRUE(center.playbackState == MPNowPlayingPlaybackStatePlaying);
+  ASSERT_TRUE(listener->IsResultEqualTo(MediaControlKey::Playpause));
+}
+
+TEST(MediaHardwareKeysEventSourceMacMediaCenter, TestMediaCenterPlayEvent)
+{
+  RefPtr<MediaHardwareKeysEventSourceMacMediaCenter> source =
+      new MediaHardwareKeysEventSourceMacMediaCenter();
+
+  ASSERT_TRUE(source->GetListenersNum() == 0);
+
+  RefPtr<MediaKeyListenerTest> listener = new MediaKeyListenerTest();
+
+  MPNowPlayingInfoCenter* center = [MPNowPlayingInfoCenter defaultCenter];
+
+  source->AddListener(listener.get());
+
+  ASSERT_TRUE(source->Open());
+
+  ASSERT_TRUE(source->GetListenersNum() == 1);
+  ASSERT_TRUE(!listener->IsReceivedResult());
+  ASSERT_TRUE(center.playbackState == MPNowPlayingPlaybackStatePlaying);
+
+  MediaCenterEventHandler playHandler = source->CreatePlayHandler();
+
+  center.playbackState = MPNowPlayingPlaybackStatePaused;
+
+  playHandler(nil);
+
+  ASSERT_TRUE(center.playbackState == MPNowPlayingPlaybackStatePlaying);
+  ASSERT_TRUE(listener->IsResultEqualTo(MediaControlKey::Play));
+}
+
+TEST(MediaHardwareKeysEventSourceMacMediaCenter, TestMediaCenterPauseEvent)
+{
+  RefPtr<MediaHardwareKeysEventSourceMacMediaCenter> source =
+      new MediaHardwareKeysEventSourceMacMediaCenter();
+
+  ASSERT_TRUE(source->GetListenersNum() == 0);
+
+  RefPtr<MediaKeyListenerTest> listener = new MediaKeyListenerTest();
+
+  MPNowPlayingInfoCenter* center = [MPNowPlayingInfoCenter defaultCenter];
+
+  source->AddListener(listener.get());
+
+  ASSERT_TRUE(source->Open());
+
+  ASSERT_TRUE(source->GetListenersNum() == 1);
+  ASSERT_TRUE(!listener->IsReceivedResult());
+  ASSERT_TRUE(center.playbackState == MPNowPlayingPlaybackStatePlaying);
+
+  MediaCenterEventHandler pauseHandler = source->CreatePauseHandler();
+
+  pauseHandler(nil);
+
+  ASSERT_TRUE(center.playbackState == MPNowPlayingPlaybackStatePaused);
+  ASSERT_TRUE(listener->IsResultEqualTo(MediaControlKey::Pause));
+}
+
+TEST(MediaHardwareKeysEventSourceMacMediaCenter, TestMediaCenterPrevNextEvent)
+{
+  RefPtr<MediaHardwareKeysEventSourceMacMediaCenter> source =
+      new MediaHardwareKeysEventSourceMacMediaCenter();
+
+  ASSERT_TRUE(source->GetListenersNum() == 0);
+
+  RefPtr<MediaKeyListenerTest> listener = new MediaKeyListenerTest();
+
+  source->AddListener(listener.get());
+
+  ASSERT_TRUE(source->Open());
+
+  MediaCenterEventHandler nextHandler = source->CreateNextTrackHandler();
+
+  nextHandler(nil);
+
+  ASSERT_TRUE(listener->IsResultEqualTo(MediaControlKey::Nexttrack));
+
+  MediaCenterEventHandler previousHandler = source->CreatePreviousTrackHandler();
+
+  previousHandler(nil);
+
+  ASSERT_TRUE(listener->IsResultEqualTo(MediaControlKey::Previoustrack));
+}
+
+TEST(MediaHardwareKeysEventSourceMacMediaCenter, TestSetMetadata)
+{
+  RefPtr<MediaHardwareKeysEventSourceMacMediaCenter> source =
+      new MediaHardwareKeysEventSourceMacMediaCenter();
+
+  ASSERT_TRUE(source->GetListenersNum() == 0);
+
+  RefPtr<MediaKeyListenerTest> listener = new MediaKeyListenerTest();
+
+  source->AddListener(listener.get());
+
+  ASSERT_TRUE(source->Open());
+
+  MediaMetadataBase metadata;
+  metadata.mTitle = u"MediaPlayback";
+  metadata.mArtist = u"Firefox";
+  metadata.mAlbum = u"Mozilla";
+  source->SetMediaMetadata(metadata);
+
+  // The update procedure of nowPlayingInfo is async, so wait for a second
+  // before checking the result.
+  PR_Sleep(PR_SecondsToInterval(1));
+  MPNowPlayingInfoCenter* center = [MPNowPlayingInfoCenter defaultCenter];
+  ASSERT_TRUE([center.nowPlayingInfo[MPMediaItemPropertyTitle] isEqualToString:@"MediaPlayback"]);
+  ASSERT_TRUE([center.nowPlayingInfo[MPMediaItemPropertyArtist] isEqualToString:@"Firefox"]);
+  ASSERT_TRUE([center.nowPlayingInfo[MPMediaItemPropertyAlbumTitle] isEqualToString:@"Mozilla"]);
+
+  source->Close();
+  PR_Sleep(PR_SecondsToInterval(1));
+  ASSERT_TRUE(center.nowPlayingInfo == nil);
+}
+
+NS_ASSUME_NONNULL_END
diff --git a/dom/media/mediacontrol/tests/gtest/moz.build b/dom/media/mediacontrol/tests/gtest/moz.build
new file mode 100644
index 0000000000..7043bfcd5e
--- /dev/null
+++ b/dom/media/mediacontrol/tests/gtest/moz.build
@@ -0,0 +1,23 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+UNIFIED_SOURCES += [
+    "TestAudioFocusManager.cpp",
+    "TestMediaController.cpp",
+    "TestMediaControlService.cpp",
+    "TestMediaKeysEvent.cpp",
+]
+
+if CONFIG["MOZ_APPLEMEDIA"]:
+    UNIFIED_SOURCES += ["TestMediaKeysEventMac.mm", "TestMediaKeysEventMediaCenter.mm"]
+
+include("/ipc/chromium/chromium-config.mozbuild")
+
+LOCAL_INCLUDES += [
+    "/dom/media/mediacontrol",
+]
+
+FINAL_LIBRARY = "xul-gtest"