Adding upstream version 115.8.0esr.upstream/115.8.0esr

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

1 files changed, 1319 insertions, 0 deletions

diff --git a/dom/media/doctor/DecoderDoctorDiagnostics.cpp b/dom/media/doctor/DecoderDoctorDiagnostics.cpp
new file mode 100644
index 0000000000..164c614547
--- /dev/null
+++ b/dom/media/doctor/DecoderDoctorDiagnostics.cpp
@@ -0,0 +1,1319 @@
+/* -*- 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/. */
+
+#include "DecoderDoctorDiagnostics.h"
+
+#include <string.h>
+
+#include "VideoUtils.h"
+#include "mozilla/Logging.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/TimeStamp.h"
+#include "mozilla/StaticPrefs_media.h"
+#include "mozilla/dom/Document.h"
+#include "nsContentUtils.h"
+#include "nsGkAtoms.h"
+#include "nsIObserverService.h"
+#include "nsIScriptError.h"
+#include "nsITimer.h"
+#include "nsPluginHost.h"
+#include "nsPrintfCString.h"
+
+#if defined(MOZ_FFMPEG)
+#  include "FFmpegRuntimeLinker.h"
+#endif
+
+static mozilla::LazyLogModule sDecoderDoctorLog("DecoderDoctor");
+#define DD_LOG(level, arg, ...) \
+  MOZ_LOG(sDecoderDoctorLog, level, (arg, ##__VA_ARGS__))
+#define DD_DEBUG(arg, ...) DD_LOG(mozilla::LogLevel::Debug, arg, ##__VA_ARGS__)
+#define DD_INFO(arg, ...) DD_LOG(mozilla::LogLevel::Info, arg, ##__VA_ARGS__)
+#define DD_WARN(arg, ...) DD_LOG(mozilla::LogLevel::Warning, arg, ##__VA_ARGS__)
+
+namespace mozilla {
+
+// Class that collects a sequence of diagnostics from the same document over a
+// small period of time, in order to provide a synthesized analysis.
+//
+// Referenced by the document through a nsINode property, mTimer, and
+// inter-task captures.
+// When notified that the document is dead, or when the timer expires but
+// nothing new happened, StopWatching() will remove the document property and
+// timer (if present), so no more work will happen and the watcher will be
+// destroyed once all references are gone.
+class DecoderDoctorDocumentWatcher : public nsITimerCallback, public nsINamed {
+ public:
+  static already_AddRefed<DecoderDoctorDocumentWatcher> RetrieveOrCreate(
+      dom::Document* aDocument);
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSITIMERCALLBACK
+  NS_DECL_NSINAMED
+
+  void AddDiagnostics(DecoderDoctorDiagnostics&& aDiagnostics,
+                      const char* aCallSite);
+
+ private:
+  explicit DecoderDoctorDocumentWatcher(dom::Document* aDocument);
+  virtual ~DecoderDoctorDocumentWatcher();
+
+  // This will prevent further work from happening, watcher will deregister
+  // itself from document (if requested) and cancel any timer, and soon die.
+  void StopWatching(bool aRemoveProperty);
+
+  // Remove property from document; will call DestroyPropertyCallback.
+  void RemovePropertyFromDocument();
+  // Callback for property destructor, will be automatically called when the
+  // document (in aObject) is being destroyed.
+  static void DestroyPropertyCallback(void* aObject, nsAtom* aPropertyName,
+                                      void* aPropertyValue, void* aData);
+
+  static const uint32_t sAnalysisPeriod_ms = 1000;
+  void EnsureTimerIsStarted();
+
+  void SynthesizeAnalysis();
+  // This is used for testing and will generate an analysis based on the value
+  // set in `media.decoder-doctor.testing.fake-error`.
+  void SynthesizeFakeAnalysis();
+  bool ShouldSynthesizeFakeAnalysis() const;
+
+  // Raw pointer to a Document.
+  // Must be non-null during construction.
+  // Nulled when we want to stop watching, because either:
+  // 1. The document has been destroyed (notified through
+  //    DestroyPropertyCallback).
+  // 2. We have not received new diagnostic information within a short time
+  //    period, so we just stop watching.
+  // Once nulled, no more actual work will happen, and the watcher will be
+  // destroyed soon.
+  dom::Document* mDocument;
+
+  struct Diagnostics {
+    Diagnostics(DecoderDoctorDiagnostics&& aDiagnostics, const char* aCallSite,
+                mozilla::TimeStamp aTimeStamp)
+        : mDecoderDoctorDiagnostics(std::move(aDiagnostics)),
+          mCallSite(aCallSite),
+          mTimeStamp(aTimeStamp) {}
+    Diagnostics(const Diagnostics&) = delete;
+    Diagnostics(Diagnostics&& aOther)
+        : mDecoderDoctorDiagnostics(
+              std::move(aOther.mDecoderDoctorDiagnostics)),
+          mCallSite(std::move(aOther.mCallSite)),
+          mTimeStamp(aOther.mTimeStamp) {}
+
+    const DecoderDoctorDiagnostics mDecoderDoctorDiagnostics;
+    const nsCString mCallSite;
+    const mozilla::TimeStamp mTimeStamp;
+  };
+  typedef nsTArray<Diagnostics> DiagnosticsSequence;
+  DiagnosticsSequence mDiagnosticsSequence;
+
+  nsCOMPtr<nsITimer> mTimer;  // Keep timer alive until we run.
+  DiagnosticsSequence::size_type mDiagnosticsHandled = 0;
+};
+
+NS_IMPL_ISUPPORTS(DecoderDoctorDocumentWatcher, nsITimerCallback, nsINamed)
+
+// static
+already_AddRefed<DecoderDoctorDocumentWatcher>
+DecoderDoctorDocumentWatcher::RetrieveOrCreate(dom::Document* aDocument) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(aDocument);
+  RefPtr<DecoderDoctorDocumentWatcher> watcher =
+      static_cast<DecoderDoctorDocumentWatcher*>(
+          aDocument->GetProperty(nsGkAtoms::decoderDoctor));
+  if (!watcher) {
+    watcher = new DecoderDoctorDocumentWatcher(aDocument);
+    if (NS_WARN_IF(NS_FAILED(aDocument->SetProperty(
+            nsGkAtoms::decoderDoctor, watcher.get(), DestroyPropertyCallback,
+            /*transfer*/ false)))) {
+      DD_WARN(
+          "DecoderDoctorDocumentWatcher::RetrieveOrCreate(doc=%p) - Could not "
+          "set property in document, will destroy new watcher[%p]",
+          aDocument, watcher.get());
+      return nullptr;
+    }
+    // Document owns watcher through this property.
+    // Released in DestroyPropertyCallback().
+    NS_ADDREF(watcher.get());
+  }
+  return watcher.forget();
+}
+
+DecoderDoctorDocumentWatcher::DecoderDoctorDocumentWatcher(
+    dom::Document* aDocument)
+    : mDocument(aDocument) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(mDocument);
+  DD_DEBUG(
+      "DecoderDoctorDocumentWatcher[%p]::DecoderDoctorDocumentWatcher(doc=%p)",
+      this, mDocument);
+}
+
+DecoderDoctorDocumentWatcher::~DecoderDoctorDocumentWatcher() {
+  MOZ_ASSERT(NS_IsMainThread());
+  DD_DEBUG(
+      "DecoderDoctorDocumentWatcher[%p, doc=%p <- expect "
+      "0]::~DecoderDoctorDocumentWatcher()",
+      this, mDocument);
+  // mDocument should have been reset through StopWatching()!
+  MOZ_ASSERT(!mDocument);
+}
+
+void DecoderDoctorDocumentWatcher::RemovePropertyFromDocument() {
+  MOZ_ASSERT(NS_IsMainThread());
+  DecoderDoctorDocumentWatcher* watcher =
+      static_cast<DecoderDoctorDocumentWatcher*>(
+          mDocument->GetProperty(nsGkAtoms::decoderDoctor));
+  if (!watcher) {
+    return;
+  }
+  DD_DEBUG(
+      "DecoderDoctorDocumentWatcher[%p, "
+      "doc=%p]::RemovePropertyFromDocument()\n",
+      watcher, watcher->mDocument);
+  // This will call our DestroyPropertyCallback.
+  mDocument->RemoveProperty(nsGkAtoms::decoderDoctor);
+}
+
+// Callback for property destructors. |aObject| is the object
+// the property is being removed for, |aPropertyName| is the property
+// being removed, |aPropertyValue| is the value of the property, and |aData|
+// is the opaque destructor data that was passed to SetProperty().
+// static
+void DecoderDoctorDocumentWatcher::DestroyPropertyCallback(
+    void* aObject, nsAtom* aPropertyName, void* aPropertyValue, void*) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(aPropertyName == nsGkAtoms::decoderDoctor);
+  DecoderDoctorDocumentWatcher* watcher =
+      static_cast<DecoderDoctorDocumentWatcher*>(aPropertyValue);
+  MOZ_ASSERT(watcher);
+#ifdef DEBUG
+  auto* document = static_cast<dom::Document*>(aObject);
+  MOZ_ASSERT(watcher->mDocument == document);
+#endif
+  DD_DEBUG(
+      "DecoderDoctorDocumentWatcher[%p, doc=%p]::DestroyPropertyCallback()\n",
+      watcher, watcher->mDocument);
+  // 'false': StopWatching should not try and remove the property.
+  watcher->StopWatching(false);
+  NS_RELEASE(watcher);
+}
+
+void DecoderDoctorDocumentWatcher::StopWatching(bool aRemoveProperty) {
+  MOZ_ASSERT(NS_IsMainThread());
+  // StopWatching() shouldn't be called twice.
+  MOZ_ASSERT(mDocument);
+
+  if (aRemoveProperty) {
+    RemovePropertyFromDocument();
+  }
+
+  // Forget document now, this will prevent more work from being started.
+  mDocument = nullptr;
+
+  if (mTimer) {
+    mTimer->Cancel();
+    mTimer = nullptr;
+  }
+}
+
+void DecoderDoctorDocumentWatcher::EnsureTimerIsStarted() {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (!mTimer) {
+    NS_NewTimerWithCallback(getter_AddRefs(mTimer), this, sAnalysisPeriod_ms,
+                            nsITimer::TYPE_ONE_SHOT);
+  }
+}
+
+enum class ReportParam : uint8_t {
+  // Marks the end of the parameter list.
+  // Keep this zero! (For implicit zero-inits when used in definitions below.)
+  None = 0,
+
+  Formats,
+  DecodeIssue,
+  DocURL,
+  ResourceURL
+};
+
+struct NotificationAndReportStringId {
+  // Notification type, handled by DecoderDoctorChild.sys.mjs and
+  // DecoderDoctorParent.sys.mjs.
+  dom::DecoderDoctorNotificationType mNotificationType;
+  // Console message id. Key in dom/locales/.../chrome/dom/dom.properties.
+  const char* mReportStringId;
+  static const int maxReportParams = 4;
+  ReportParam mReportParams[maxReportParams];
+};
+
+// Note: ReportStringIds are limited to alphanumeric only.
+static const NotificationAndReportStringId sMediaWidevineNoWMF = {
+    dom::DecoderDoctorNotificationType::Platform_decoder_not_found,
+    "MediaWidevineNoWMF",
+    {ReportParam::None}};
+static const NotificationAndReportStringId sMediaWMFNeeded = {
+    dom::DecoderDoctorNotificationType::Platform_decoder_not_found,
+    "MediaWMFNeeded",
+    {ReportParam::Formats}};
+static const NotificationAndReportStringId sMediaFFMpegNotFound = {
+    dom::DecoderDoctorNotificationType::Platform_decoder_not_found,
+    "MediaPlatformDecoderNotFound",
+    {ReportParam::Formats}};
+static const NotificationAndReportStringId sMediaCannotPlayNoDecoders = {
+    dom::DecoderDoctorNotificationType::Cannot_play,
+    "MediaCannotPlayNoDecoders",
+    {ReportParam::Formats}};
+static const NotificationAndReportStringId sMediaNoDecoders = {
+    dom::DecoderDoctorNotificationType::Can_play_but_some_missing_decoders,
+    "MediaNoDecoders",
+    {ReportParam::Formats}};
+static const NotificationAndReportStringId sCannotInitializePulseAudio = {
+    dom::DecoderDoctorNotificationType::Cannot_initialize_pulseaudio,
+    "MediaCannotInitializePulseAudio",
+    {ReportParam::None}};
+static const NotificationAndReportStringId sUnsupportedLibavcodec = {
+    dom::DecoderDoctorNotificationType::Unsupported_libavcodec,
+    "MediaUnsupportedLibavcodec",
+    {ReportParam::None}};
+static const NotificationAndReportStringId sMediaDecodeError = {
+    dom::DecoderDoctorNotificationType::Decode_error,
+    "MediaDecodeError",
+    {ReportParam::ResourceURL, ReportParam::DecodeIssue}};
+static const NotificationAndReportStringId sMediaDecodeWarning = {
+    dom::DecoderDoctorNotificationType::Decode_warning,
+    "MediaDecodeWarning",
+    {ReportParam::ResourceURL, ReportParam::DecodeIssue}};
+
+static const NotificationAndReportStringId* const
+    sAllNotificationsAndReportStringIds[] = {
+        &sMediaWidevineNoWMF,    &sMediaWMFNeeded,
+        &sMediaFFMpegNotFound,   &sMediaCannotPlayNoDecoders,
+        &sMediaNoDecoders,       &sCannotInitializePulseAudio,
+        &sUnsupportedLibavcodec, &sMediaDecodeError,
+        &sMediaDecodeWarning};
+
+// Create a webcompat-friendly description of a MediaResult.
+static nsString MediaResultDescription(const MediaResult& aResult,
+                                       bool aIsError) {
+  nsCString name;
+  GetErrorName(aResult.Code(), name);
+  return NS_ConvertUTF8toUTF16(nsPrintfCString(
+      "%s Code: %s (0x%08" PRIx32 ")%s%s", aIsError ? "Error" : "Warning",
+      name.get(), static_cast<uint32_t>(aResult.Code()),
+      aResult.Message().IsEmpty() ? "" : "\nDetails: ",
+      aResult.Message().get()));
+}
+
+static bool IsNotificationAllowedOnPlatform(
+    const NotificationAndReportStringId& aNotification) {
+  // Allow all notifications during testing.
+  if (StaticPrefs::media_decoder_doctor_testing()) {
+    return true;
+  }
+  // These notifications are platform independent.
+  if (aNotification.mNotificationType ==
+          dom::DecoderDoctorNotificationType::Cannot_play ||
+      aNotification.mNotificationType ==
+          dom::DecoderDoctorNotificationType::
+              Can_play_but_some_missing_decoders ||
+      aNotification.mNotificationType ==
+          dom::DecoderDoctorNotificationType::Decode_error ||
+      aNotification.mNotificationType ==
+          dom::DecoderDoctorNotificationType::Decode_warning) {
+    return true;
+  }
+#if defined(XP_WIN)
+  if (aNotification.mNotificationType ==
+      dom::DecoderDoctorNotificationType::Platform_decoder_not_found) {
+    return strcmp(sMediaWMFNeeded.mReportStringId,
+                  aNotification.mReportStringId) == 0 ||
+           strcmp(sMediaWidevineNoWMF.mReportStringId,
+                  aNotification.mReportStringId) == 0;
+  }
+#endif
+#if defined(MOZ_FFMPEG)
+  if (aNotification.mNotificationType ==
+      dom::DecoderDoctorNotificationType::Platform_decoder_not_found) {
+    return strcmp(sMediaFFMpegNotFound.mReportStringId,
+                  aNotification.mReportStringId) == 0;
+  }
+  if (aNotification.mNotificationType ==
+      dom::DecoderDoctorNotificationType::Unsupported_libavcodec) {
+    return strcmp(sUnsupportedLibavcodec.mReportStringId,
+                  aNotification.mReportStringId) == 0;
+  }
+#endif
+#ifdef MOZ_PULSEAUDIO
+  if (aNotification.mNotificationType ==
+      dom::DecoderDoctorNotificationType::Cannot_initialize_pulseaudio) {
+    return strcmp(sCannotInitializePulseAudio.mReportStringId,
+                  aNotification.mReportStringId) == 0;
+  }
+#endif
+  return false;
+}
+
+static void DispatchNotification(
+    nsISupports* aSubject, const NotificationAndReportStringId& aNotification,
+    bool aIsSolved, const nsAString& aFormats, const nsAString& aDecodeIssue,
+    const nsACString& aDocURL, const nsAString& aResourceURL) {
+  if (!aSubject) {
+    return;
+  }
+  dom::DecoderDoctorNotification data;
+  data.mType = aNotification.mNotificationType;
+  data.mIsSolved = aIsSolved;
+  data.mDecoderDoctorReportId.Assign(
+      NS_ConvertUTF8toUTF16(aNotification.mReportStringId));
+  if (!aFormats.IsEmpty()) {
+    data.mFormats.Construct(aFormats);
+  }
+  if (!aDecodeIssue.IsEmpty()) {
+    data.mDecodeIssue.Construct(aDecodeIssue);
+  }
+  if (!aDocURL.IsEmpty()) {
+    data.mDocURL.Construct(NS_ConvertUTF8toUTF16(aDocURL));
+  }
+  if (!aResourceURL.IsEmpty()) {
+    data.mResourceURL.Construct(aResourceURL);
+  }
+  nsAutoString json;
+  data.ToJSON(json);
+  if (json.IsEmpty()) {
+    DD_WARN(
+        "DecoderDoctorDiagnostics/DispatchEvent() - Could not create json for "
+        "dispatch");
+    // No point in dispatching this notification without data, the front-end
+    // wouldn't know what to display.
+    return;
+  }
+  DD_DEBUG("DecoderDoctorDiagnostics/DispatchEvent() %s",
+           NS_ConvertUTF16toUTF8(json).get());
+  nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
+  if (obs) {
+    obs->NotifyObservers(aSubject, "decoder-doctor-notification", json.get());
+  }
+}
+
+static void ReportToConsole(dom::Document* aDocument,
+                            const char* aConsoleStringId,
+                            const nsTArray<nsString>& aParams) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(aDocument);
+
+  DD_DEBUG(
+      "DecoderDoctorDiagnostics.cpp:ReportToConsole(doc=%p) ReportToConsole"
+      " - aMsg='%s' params={%s%s%s%s}",
+      aDocument, aConsoleStringId,
+      aParams.IsEmpty() ? "<no params>"
+                        : NS_ConvertUTF16toUTF8(aParams[0]).get(),
+      (aParams.Length() < 1 || aParams[0].IsEmpty()) ? "" : ", ",
+      (aParams.Length() < 1 || aParams[0].IsEmpty())
+          ? ""
+          : NS_ConvertUTF16toUTF8(aParams[0]).get(),
+      aParams.Length() < 2 ? "" : ", ...");
+  if (StaticPrefs::media_decoder_doctor_testing()) {
+    Unused << nsContentUtils::DispatchTrustedEvent(
+        aDocument, ToSupports(aDocument), u"mozreportmediaerror"_ns,
+        CanBubble::eNo, Cancelable::eNo);
+  }
+  nsContentUtils::ReportToConsole(nsIScriptError::warningFlag, "Media"_ns,
+                                  aDocument, nsContentUtils::eDOM_PROPERTIES,
+                                  aConsoleStringId, aParams);
+}
+
+static bool AllowNotification(
+    const NotificationAndReportStringId& aNotification) {
+  // "media.decoder-doctor.notifications-allowed" controls which notifications
+  // may be dispatched to the front-end. It either contains:
+  // - '*' -> Allow everything.
+  // - Comma-separater list of ids -> Allow if aReportStringId (from
+  //                                  dom.properties) is one of them.
+  // - Nothing (missing or empty) -> Disable everything.
+  nsAutoCString filter;
+  Preferences::GetCString("media.decoder-doctor.notifications-allowed", filter);
+  return filter.EqualsLiteral("*") ||
+         StringListContains(filter, aNotification.mReportStringId);
+}
+
+static bool AllowDecodeIssue(const MediaResult& aDecodeIssue,
+                             bool aDecodeIssueIsError) {
+  if (aDecodeIssue == NS_OK) {
+    // 'NS_OK' means we are not actually reporting a decode issue, so we
+    // allow the report.
+    return true;
+  }
+
+  // "media.decoder-doctor.decode-{errors,warnings}-allowed" controls which
+  // decode issues may be dispatched to the front-end. It either contains:
+  // - '*' -> Allow everything.
+  // - Comma-separater list of ids -> Allow if the issue name is one of them.
+  // - Nothing (missing or empty) -> Disable everything.
+  nsAutoCString filter;
+  Preferences::GetCString(aDecodeIssueIsError
+                              ? "media.decoder-doctor.decode-errors-allowed"
+                              : "media.decoder-doctor.decode-warnings-allowed",
+                          filter);
+  if (filter.EqualsLiteral("*")) {
+    return true;
+  }
+
+  nsCString decodeIssueName;
+  GetErrorName(aDecodeIssue.Code(), static_cast<nsACString&>(decodeIssueName));
+  return StringListContains(filter, decodeIssueName);
+}
+
+static void ReportAnalysis(dom::Document* aDocument,
+                           const NotificationAndReportStringId& aNotification,
+                           bool aIsSolved, const nsAString& aFormats = u""_ns,
+                           const MediaResult& aDecodeIssue = NS_OK,
+                           bool aDecodeIssueIsError = true,
+                           const nsACString& aDocURL = ""_ns,
+                           const nsAString& aResourceURL = u""_ns) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (!aDocument) {
+    return;
+  }
+
+  // Some errors should only appear on the specific platform. Eg. WMF related
+  // error only happens on Windows.
+  if (!IsNotificationAllowedOnPlatform(aNotification)) {
+    DD_WARN("Platform doesn't support '%s'!", aNotification.mReportStringId);
+    return;
+  }
+
+  nsString decodeIssueDescription;
+  if (aDecodeIssue != NS_OK) {
+    decodeIssueDescription.Assign(
+        MediaResultDescription(aDecodeIssue, aDecodeIssueIsError));
+  }
+
+  // Report non-solved issues to console.
+  if (!aIsSolved) {
+    // Build parameter array needed by console message.
+    AutoTArray<nsString, NotificationAndReportStringId::maxReportParams> params;
+    for (int i = 0; i < NotificationAndReportStringId::maxReportParams; ++i) {
+      if (aNotification.mReportParams[i] == ReportParam::None) {
+        break;
+      }
+      switch (aNotification.mReportParams[i]) {
+        case ReportParam::Formats:
+          params.AppendElement(aFormats);
+          break;
+        case ReportParam::DecodeIssue:
+          params.AppendElement(decodeIssueDescription);
+          break;
+        case ReportParam::DocURL:
+          params.AppendElement(NS_ConvertUTF8toUTF16(aDocURL));
+          break;
+        case ReportParam::ResourceURL:
+          params.AppendElement(aResourceURL);
+          break;
+        default:
+          MOZ_ASSERT_UNREACHABLE("Bad notification parameter choice");
+          break;
+      }
+    }
+    ReportToConsole(aDocument, aNotification.mReportStringId, params);
+  }
+
+  const bool allowNotification = AllowNotification(aNotification);
+  const bool allowDecodeIssue =
+      AllowDecodeIssue(aDecodeIssue, aDecodeIssueIsError);
+  DD_INFO(
+      "ReportAnalysis for %s (decodeResult=%s) [AllowNotification=%d, "
+      "AllowDecodeIssue=%d]",
+      aNotification.mReportStringId, aDecodeIssue.ErrorName().get(),
+      allowNotification, allowDecodeIssue);
+  if (allowNotification && allowDecodeIssue) {
+    DispatchNotification(aDocument->GetInnerWindow(), aNotification, aIsSolved,
+                         aFormats, decodeIssueDescription, aDocURL,
+                         aResourceURL);
+  }
+}
+
+static nsString CleanItemForFormatsList(const nsAString& aItem) {
+  nsString item(aItem);
+  // Remove commas from item, as commas are used to separate items. It's fine
+  // to have a one-way mapping, it's only used for comparisons and in
+  // console display (where formats shouldn't contain commas in the first place)
+  item.ReplaceChar(',', ' ');
+  item.CompressWhitespace();
+  return item;
+}
+
+static void AppendToFormatsList(nsAString& aList, const nsAString& aItem) {
+  if (!aList.IsEmpty()) {
+    aList += u", "_ns;
+  }
+  aList += CleanItemForFormatsList(aItem);
+}
+
+static bool FormatsListContains(const nsAString& aList,
+                                const nsAString& aItem) {
+  return StringListContains(aList, CleanItemForFormatsList(aItem));
+}
+
+static const char* GetLinkStatusLibraryName() {
+#if defined(MOZ_FFMPEG)
+  return FFmpegRuntimeLinker::LinkStatusLibraryName();
+#else
+  return "no library (ffmpeg disabled during build)";
+#endif
+}
+
+static const char* GetLinkStatusString() {
+#if defined(MOZ_FFMPEG)
+  return FFmpegRuntimeLinker::LinkStatusString();
+#else
+  return "no link (ffmpeg disabled during build)";
+#endif
+}
+
+void DecoderDoctorDocumentWatcher::SynthesizeFakeAnalysis() {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  nsAutoCString errorType;
+  Preferences::GetCString("media.decoder-doctor.testing.fake-error", errorType);
+  MOZ_ASSERT(!errorType.IsEmpty());
+  for (const auto& id : sAllNotificationsAndReportStringIds) {
+    if (strcmp(id->mReportStringId, errorType.get()) == 0) {
+      if (id->mNotificationType ==
+          dom::DecoderDoctorNotificationType::Decode_error) {
+        ReportAnalysis(mDocument, *id, false /* isSolved */, u"*"_ns,
+                       NS_ERROR_DOM_MEDIA_DECODE_ERR, true /* IsDecodeError */);
+      } else {
+        ReportAnalysis(mDocument, *id, false /* isSolved */, u"*"_ns, NS_OK,
+                       false /* IsDecodeError */);
+      }
+      return;
+    }
+  }
+}
+
+void DecoderDoctorDocumentWatcher::SynthesizeAnalysis() {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  nsAutoString playableFormats;
+  nsAutoString unplayableFormats;
+  // Subsets of unplayableFormats that require a specific platform decoder:
+  nsAutoString formatsRequiringWMF;
+  nsAutoString formatsRequiringFFMpeg;
+  nsAutoString formatsLibAVCodecUnsupported;
+  nsAutoString supportedKeySystems;
+  nsAutoString unsupportedKeySystems;
+  DecoderDoctorDiagnostics::KeySystemIssue lastKeySystemIssue =
+      DecoderDoctorDiagnostics::eUnset;
+  // Only deal with one decode error per document (the first one found).
+  const MediaResult* firstDecodeError = nullptr;
+  const nsString* firstDecodeErrorMediaSrc = nullptr;
+  // Only deal with one decode warning per document (the first one found).
+  const MediaResult* firstDecodeWarning = nullptr;
+  const nsString* firstDecodeWarningMediaSrc = nullptr;
+
+  for (const auto& diag : mDiagnosticsSequence) {
+    switch (diag.mDecoderDoctorDiagnostics.Type()) {
+      case DecoderDoctorDiagnostics::eFormatSupportCheck:
+        if (diag.mDecoderDoctorDiagnostics.CanPlay()) {
+          AppendToFormatsList(playableFormats,
+                              diag.mDecoderDoctorDiagnostics.Format());
+        } else {
+          AppendToFormatsList(unplayableFormats,
+                              diag.mDecoderDoctorDiagnostics.Format());
+          if (diag.mDecoderDoctorDiagnostics.DidWMFFailToLoad()) {
+            AppendToFormatsList(formatsRequiringWMF,
+                                diag.mDecoderDoctorDiagnostics.Format());
+          } else if (diag.mDecoderDoctorDiagnostics.DidFFmpegNotFound()) {
+            AppendToFormatsList(formatsRequiringFFMpeg,
+                                diag.mDecoderDoctorDiagnostics.Format());
+          } else if (diag.mDecoderDoctorDiagnostics.IsLibAVCodecUnsupported()) {
+            AppendToFormatsList(formatsLibAVCodecUnsupported,
+                                diag.mDecoderDoctorDiagnostics.Format());
+          }
+        }
+        break;
+      case DecoderDoctorDiagnostics::eMediaKeySystemAccessRequest:
+        if (diag.mDecoderDoctorDiagnostics.IsKeySystemSupported()) {
+          AppendToFormatsList(supportedKeySystems,
+                              diag.mDecoderDoctorDiagnostics.KeySystem());
+        } else {
+          AppendToFormatsList(unsupportedKeySystems,
+                              diag.mDecoderDoctorDiagnostics.KeySystem());
+          DecoderDoctorDiagnostics::KeySystemIssue issue =
+              diag.mDecoderDoctorDiagnostics.GetKeySystemIssue();
+          if (issue != DecoderDoctorDiagnostics::eUnset) {
+            lastKeySystemIssue = issue;
+          }
+        }
+        break;
+      case DecoderDoctorDiagnostics::eEvent:
+        MOZ_ASSERT_UNREACHABLE("Events shouldn't be stored for processing.");
+        break;
+      case DecoderDoctorDiagnostics::eDecodeError:
+        if (!firstDecodeError) {
+          firstDecodeError = &diag.mDecoderDoctorDiagnostics.DecodeIssue();
+          firstDecodeErrorMediaSrc =
+              &diag.mDecoderDoctorDiagnostics.DecodeIssueMediaSrc();
+        }
+        break;
+      case DecoderDoctorDiagnostics::eDecodeWarning:
+        if (!firstDecodeWarning) {
+          firstDecodeWarning = &diag.mDecoderDoctorDiagnostics.DecodeIssue();
+          firstDecodeWarningMediaSrc =
+              &diag.mDecoderDoctorDiagnostics.DecodeIssueMediaSrc();
+        }
+        break;
+      default:
+        MOZ_ASSERT_UNREACHABLE("Unhandled DecoderDoctorDiagnostics type");
+        break;
+    }
+  }
+
+  // Check if issues have been solved, by finding if some now-playable
+  // key systems or formats were previously recorded as having issues.
+  if (!supportedKeySystems.IsEmpty() || !playableFormats.IsEmpty()) {
+    DD_DEBUG(
+        "DecoderDoctorDocumentWatcher[%p, doc=%p]::SynthesizeAnalysis() - "
+        "supported key systems '%s', playable formats '%s'; See if they show "
+        "issues have been solved...",
+        this, mDocument, NS_ConvertUTF16toUTF8(supportedKeySystems).Data(),
+        NS_ConvertUTF16toUTF8(playableFormats).get());
+    const nsAString* workingFormatsArray[] = {&supportedKeySystems,
+                                              &playableFormats};
+    // For each type of notification, retrieve the pref that contains formats/
+    // key systems with issues.
+    for (const NotificationAndReportStringId* id :
+         sAllNotificationsAndReportStringIds) {
+      nsAutoCString formatsPref("media.decoder-doctor.");
+      formatsPref += id->mReportStringId;
+      formatsPref += ".formats";
+      nsAutoString formatsWithIssues;
+      Preferences::GetString(formatsPref.Data(), formatsWithIssues);
+      if (formatsWithIssues.IsEmpty()) {
+        continue;
+      }
+      // See if that list of formats-with-issues contains any formats that are
+      // now playable/supported.
+      bool solved = false;
+      for (const nsAString* workingFormats : workingFormatsArray) {
+        for (const auto& workingFormat : MakeStringListRange(*workingFormats)) {
+          if (FormatsListContains(formatsWithIssues, workingFormat)) {
+            // This now-working format used not to work -> Report solved issue.
+            DD_INFO(
+                "DecoderDoctorDocumentWatcher[%p, "
+                "doc=%p]::SynthesizeAnalysis() - %s solved ('%s' now works, it "
+                "was in pref(%s)='%s')",
+                this, mDocument, id->mReportStringId,
+                NS_ConvertUTF16toUTF8(workingFormat).get(), formatsPref.Data(),
+                NS_ConvertUTF16toUTF8(formatsWithIssues).get());
+            ReportAnalysis(mDocument, *id, true, workingFormat);
+            // This particular Notification&ReportId has been solved, no need
+            // to keep looking at other keysys/formats that might solve it too.
+            solved = true;
+            break;
+          }
+        }
+        if (solved) {
+          break;
+        }
+      }
+      if (!solved) {
+        DD_DEBUG(
+            "DecoderDoctorDocumentWatcher[%p, doc=%p]::SynthesizeAnalysis() - "
+            "%s not solved (pref(%s)='%s')",
+            this, mDocument, id->mReportStringId, formatsPref.Data(),
+            NS_ConvertUTF16toUTF8(formatsWithIssues).get());
+      }
+    }
+  }
+
+  // Look at Key System issues first, as they take precedence over format
+  // checks.
+  if (!unsupportedKeySystems.IsEmpty() && supportedKeySystems.IsEmpty()) {
+    // No supported key systems!
+    switch (lastKeySystemIssue) {
+      case DecoderDoctorDiagnostics::eWidevineWithNoWMF:
+        DD_INFO(
+            "DecoderDoctorDocumentWatcher[%p, doc=%p]::SynthesizeAnalysis() - "
+            "unsupported key systems: %s, Widevine without WMF",
+            this, mDocument,
+            NS_ConvertUTF16toUTF8(unsupportedKeySystems).get());
+        ReportAnalysis(mDocument, sMediaWidevineNoWMF, false,
+                       unsupportedKeySystems);
+        return;
+      default:
+        break;
+    }
+  }
+
+  // Next, check playability of requested formats.
+  if (!unplayableFormats.IsEmpty()) {
+    // Some requested formats cannot be played.
+    if (playableFormats.IsEmpty()) {
+      // No requested formats can be played. See if we can help the user, by
+      // going through expected decoders from most to least desirable.
+      if (!formatsRequiringWMF.IsEmpty()) {
+        DD_INFO(
+            "DecoderDoctorDocumentWatcher[%p, doc=%p]::SynthesizeAnalysis() - "
+            "unplayable formats: %s -> Cannot play media because WMF was not "
+            "found",
+            this, mDocument, NS_ConvertUTF16toUTF8(formatsRequiringWMF).get());
+        ReportAnalysis(mDocument, sMediaWMFNeeded, false, formatsRequiringWMF);
+        return;
+      }
+      if (!formatsRequiringFFMpeg.IsEmpty()) {
+        MOZ_DIAGNOSTIC_ASSERT(formatsLibAVCodecUnsupported.IsEmpty());
+        DD_INFO(
+            "DecoderDoctorDocumentWatcher[%p, "
+            "doc=%p]::SynthesizeAnalysis() - unplayable formats: %s -> "
+            "Cannot play media because ffmpeg was not found (Reason: %s)",
+            this, mDocument,
+            NS_ConvertUTF16toUTF8(formatsRequiringFFMpeg).get(),
+            GetLinkStatusString());
+        ReportAnalysis(mDocument, sMediaFFMpegNotFound, false,
+                       formatsRequiringFFMpeg);
+        return;
+      }
+      if (!formatsLibAVCodecUnsupported.IsEmpty()) {
+        MOZ_DIAGNOSTIC_ASSERT(formatsRequiringFFMpeg.IsEmpty());
+        DD_INFO(
+            "DecoderDoctorDocumentWatcher[%p, "
+            "doc=%p]::SynthesizeAnalysis() - unplayable formats: %s -> "
+            "Cannot play media because of unsupported %s (Reason: %s)",
+            this, mDocument,
+            NS_ConvertUTF16toUTF8(formatsLibAVCodecUnsupported).get(),
+            GetLinkStatusLibraryName(), GetLinkStatusString());
+        ReportAnalysis(mDocument, sUnsupportedLibavcodec, false,
+                       formatsLibAVCodecUnsupported);
+        return;
+      }
+      DD_INFO(
+          "DecoderDoctorDocumentWatcher[%p, doc=%p]::SynthesizeAnalysis() - "
+          "Cannot play media, unplayable formats: %s",
+          this, mDocument, NS_ConvertUTF16toUTF8(unplayableFormats).get());
+      ReportAnalysis(mDocument, sMediaCannotPlayNoDecoders, false,
+                     unplayableFormats);
+      return;
+    }
+
+    DD_INFO(
+        "DecoderDoctorDocumentWatcher[%p, doc=%p]::SynthesizeAnalysis() - Can "
+        "play media, but no decoders for some requested formats: %s",
+        this, mDocument, NS_ConvertUTF16toUTF8(unplayableFormats).get());
+    if (Preferences::GetBool("media.decoder-doctor.verbose", false)) {
+      ReportAnalysis(mDocument, sMediaNoDecoders, false, unplayableFormats);
+    }
+    return;
+  }
+
+  if (firstDecodeError) {
+    DD_INFO(
+        "DecoderDoctorDocumentWatcher[%p, doc=%p]::SynthesizeAnalysis() - "
+        "Decode error: %s",
+        this, mDocument, firstDecodeError->Description().get());
+    ReportAnalysis(mDocument, sMediaDecodeError, false, u""_ns,
+                   *firstDecodeError,
+                   true,  // aDecodeIssueIsError=true
+                   mDocument->GetDocumentURI()->GetSpecOrDefault(),
+                   *firstDecodeErrorMediaSrc);
+    return;
+  }
+
+  if (firstDecodeWarning) {
+    DD_INFO(
+        "DecoderDoctorDocumentWatcher[%p, doc=%p]::SynthesizeAnalysis() - "
+        "Decode warning: %s",
+        this, mDocument, firstDecodeWarning->Description().get());
+    ReportAnalysis(mDocument, sMediaDecodeWarning, false, u""_ns,
+                   *firstDecodeWarning,
+                   false,  // aDecodeIssueIsError=false
+                   mDocument->GetDocumentURI()->GetSpecOrDefault(),
+                   *firstDecodeWarningMediaSrc);
+    return;
+  }
+
+  DD_DEBUG(
+      "DecoderDoctorDocumentWatcher[%p, doc=%p]::SynthesizeAnalysis() - Can "
+      "play media, decoders available for all requested formats",
+      this, mDocument);
+}
+
+void DecoderDoctorDocumentWatcher::AddDiagnostics(
+    DecoderDoctorDiagnostics&& aDiagnostics, const char* aCallSite) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(aDiagnostics.Type() != DecoderDoctorDiagnostics::eEvent);
+
+  if (!mDocument) {
+    return;
+  }
+
+  const mozilla::TimeStamp now = mozilla::TimeStamp::Now();
+
+  constexpr size_t MaxDiagnostics = 128;
+  constexpr double MaxSeconds = 10.0;
+  while (
+      mDiagnosticsSequence.Length() > MaxDiagnostics ||
+      (!mDiagnosticsSequence.IsEmpty() &&
+       (now - mDiagnosticsSequence[0].mTimeStamp).ToSeconds() > MaxSeconds)) {
+    // Too many, or too old.
+    mDiagnosticsSequence.RemoveElementAt(0);
+    if (mDiagnosticsHandled != 0) {
+      // Make sure Notify picks up the new element added below.
+      --mDiagnosticsHandled;
+    }
+  }
+
+  DD_DEBUG(
+      "DecoderDoctorDocumentWatcher[%p, "
+      "doc=%p]::AddDiagnostics(DecoderDoctorDiagnostics{%s}, call site '%s')",
+      this, mDocument, aDiagnostics.GetDescription().Data(), aCallSite);
+  mDiagnosticsSequence.AppendElement(
+      Diagnostics(std::move(aDiagnostics), aCallSite, now));
+  EnsureTimerIsStarted();
+}
+
+bool DecoderDoctorDocumentWatcher::ShouldSynthesizeFakeAnalysis() const {
+  if (!StaticPrefs::media_decoder_doctor_testing()) {
+    return false;
+  }
+  nsAutoCString errorType;
+  Preferences::GetCString("media.decoder-doctor.testing.fake-error", errorType);
+  return !errorType.IsEmpty();
+}
+
+NS_IMETHODIMP
+DecoderDoctorDocumentWatcher::Notify(nsITimer* timer) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(timer == mTimer);
+
+  // Forget timer. (Assuming timer keeps itself and us alive during this call.)
+  mTimer = nullptr;
+
+  if (!mDocument) {
+    return NS_OK;
+  }
+
+  if (mDiagnosticsSequence.Length() > mDiagnosticsHandled) {
+    // We have new diagnostic data.
+    mDiagnosticsHandled = mDiagnosticsSequence.Length();
+
+    if (ShouldSynthesizeFakeAnalysis()) {
+      SynthesizeFakeAnalysis();
+    } else {
+      SynthesizeAnalysis();
+    }
+
+    // Restart timer, to redo analysis or stop watching this document,
+    // depending on whether anything new happens.
+    EnsureTimerIsStarted();
+  } else {
+    DD_DEBUG(
+        "DecoderDoctorDocumentWatcher[%p, doc=%p]::Notify() - No new "
+        "diagnostics to analyze -> Stop watching",
+        this, mDocument);
+    // Stop watching this document, we don't expect more diagnostics for now.
+    // If more diagnostics come in, we'll treat them as another burst,
+    // separately. 'true' to remove the property from the document.
+    StopWatching(true);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+DecoderDoctorDocumentWatcher::GetName(nsACString& aName) {
+  aName.AssignLiteral("DecoderDoctorDocumentWatcher_timer");
+  return NS_OK;
+}
+
+void DecoderDoctorDiagnostics::StoreFormatDiagnostics(dom::Document* aDocument,
+                                                      const nsAString& aFormat,
+                                                      bool aCanPlay,
+                                                      const char* aCallSite) {
+  MOZ_ASSERT(NS_IsMainThread());
+  // Make sure we only store once.
+  MOZ_ASSERT(mDiagnosticsType == eUnsaved);
+  mDiagnosticsType = eFormatSupportCheck;
+
+  if (NS_WARN_IF(aFormat.Length() > 2048)) {
+    DD_WARN(
+        "DecoderDoctorDiagnostics[%p]::StoreFormatDiagnostics(Document* "
+        "aDocument=%p, format= TOO LONG! '%s', can-play=%d, call site '%s')",
+        aDocument, this, NS_ConvertUTF16toUTF8(aFormat).get(), aCanPlay,
+        aCallSite);
+    return;
+  }
+
+  if (NS_WARN_IF(!aDocument)) {
+    DD_WARN(
+        "DecoderDoctorDiagnostics[%p]::StoreFormatDiagnostics(Document* "
+        "aDocument=nullptr, format='%s', can-play=%d, call site '%s')",
+        this, NS_ConvertUTF16toUTF8(aFormat).get(), aCanPlay, aCallSite);
+    return;
+  }
+  if (NS_WARN_IF(aFormat.IsEmpty())) {
+    DD_WARN(
+        "DecoderDoctorDiagnostics[%p]::StoreFormatDiagnostics(Document* "
+        "aDocument=%p, format=<empty>, can-play=%d, call site '%s')",
+        this, aDocument, aCanPlay, aCallSite);
+    return;
+  }
+
+  RefPtr<DecoderDoctorDocumentWatcher> watcher =
+      DecoderDoctorDocumentWatcher::RetrieveOrCreate(aDocument);
+
+  if (NS_WARN_IF(!watcher)) {
+    DD_WARN(
+        "DecoderDoctorDiagnostics[%p]::StoreFormatDiagnostics(Document* "
+        "aDocument=%p, format='%s', can-play=%d, call site '%s') - Could not "
+        "create document watcher",
+        this, aDocument, NS_ConvertUTF16toUTF8(aFormat).get(), aCanPlay,
+        aCallSite);
+    return;
+  }
+
+  mFormat = aFormat;
+  if (aCanPlay) {
+    mFlags += Flags::CanPlay;
+  } else {
+    mFlags -= Flags::CanPlay;
+  }
+
+  // StoreDiagnostics should only be called once, after all data is available,
+  // so it is safe to std::move() from this object.
+  watcher->AddDiagnostics(std::move(*this), aCallSite);
+  // Even though it's moved-from, the type should stay set
+  // (Only used to ensure that we do store only once.)
+  MOZ_ASSERT(mDiagnosticsType == eFormatSupportCheck);
+}
+
+void DecoderDoctorDiagnostics::StoreMediaKeySystemAccess(
+    dom::Document* aDocument, const nsAString& aKeySystem, bool aIsSupported,
+    const char* aCallSite) {
+  MOZ_ASSERT(NS_IsMainThread());
+  // Make sure we only store once.
+  MOZ_ASSERT(mDiagnosticsType == eUnsaved);
+  mDiagnosticsType = eMediaKeySystemAccessRequest;
+
+  if (NS_WARN_IF(aKeySystem.Length() > 2048)) {
+    DD_WARN(
+        "DecoderDoctorDiagnostics[%p]::StoreMediaKeySystemAccess(Document* "
+        "aDocument=%p, keysystem= TOO LONG! '%s', supported=%d, call site "
+        "'%s')",
+        aDocument, this, NS_ConvertUTF16toUTF8(aKeySystem).get(), aIsSupported,
+        aCallSite);
+    return;
+  }
+
+  if (NS_WARN_IF(!aDocument)) {
+    DD_WARN(
+        "DecoderDoctorDiagnostics[%p]::StoreMediaKeySystemAccess(Document* "
+        "aDocument=nullptr, keysystem='%s', supported=%d, call site '%s')",
+        this, NS_ConvertUTF16toUTF8(aKeySystem).get(), aIsSupported, aCallSite);
+    return;
+  }
+  if (NS_WARN_IF(aKeySystem.IsEmpty())) {
+    DD_WARN(
+        "DecoderDoctorDiagnostics[%p]::StoreMediaKeySystemAccess(Document* "
+        "aDocument=%p, keysystem=<empty>, supported=%d, call site '%s')",
+        this, aDocument, aIsSupported, aCallSite);
+    return;
+  }
+
+  RefPtr<DecoderDoctorDocumentWatcher> watcher =
+      DecoderDoctorDocumentWatcher::RetrieveOrCreate(aDocument);
+
+  if (NS_WARN_IF(!watcher)) {
+    DD_WARN(
+        "DecoderDoctorDiagnostics[%p]::StoreMediaKeySystemAccess(Document* "
+        "aDocument=%p, keysystem='%s', supported=%d, call site '%s') - Could "
+        "not create document watcher",
+        this, aDocument, NS_ConvertUTF16toUTF8(aKeySystem).get(), aIsSupported,
+        aCallSite);
+    return;
+  }
+
+  mKeySystem = aKeySystem;
+  mIsKeySystemSupported = aIsSupported;
+
+  // StoreMediaKeySystemAccess should only be called once, after all data is
+  // available, so it is safe to std::move() from this object.
+  watcher->AddDiagnostics(std::move(*this), aCallSite);
+  // Even though it's moved-from, the type should stay set
+  // (Only used to ensure that we do store only once.)
+  MOZ_ASSERT(mDiagnosticsType == eMediaKeySystemAccessRequest);
+}
+
+void DecoderDoctorDiagnostics::StoreEvent(dom::Document* aDocument,
+                                          const DecoderDoctorEvent& aEvent,
+                                          const char* aCallSite) {
+  MOZ_ASSERT(NS_IsMainThread());
+  // Make sure we only store once.
+  MOZ_ASSERT(mDiagnosticsType == eUnsaved);
+  mDiagnosticsType = eEvent;
+  mEvent = aEvent;
+
+  if (NS_WARN_IF(!aDocument)) {
+    DD_WARN(
+        "DecoderDoctorDiagnostics[%p]::StoreEvent(Document* "
+        "aDocument=nullptr, aEvent=%s, call site '%s')",
+        this, GetDescription().get(), aCallSite);
+    return;
+  }
+
+  // Don't keep events for later processing, just handle them now.
+  switch (aEvent.mDomain) {
+    case DecoderDoctorEvent::eAudioSinkStartup:
+      if (aEvent.mResult == NS_ERROR_DOM_MEDIA_CUBEB_INITIALIZATION_ERR) {
+        DD_INFO(
+            "DecoderDoctorDocumentWatcher[%p, doc=%p]::AddDiagnostics() - "
+            "unable to initialize PulseAudio",
+            this, aDocument);
+        ReportAnalysis(aDocument, sCannotInitializePulseAudio, false, u"*"_ns);
+      } else if (aEvent.mResult == NS_OK) {
+        DD_INFO(
+            "DecoderDoctorDocumentWatcher[%p, doc=%p]::AddDiagnostics() - now "
+            "able to initialize PulseAudio",
+            this, aDocument);
+        ReportAnalysis(aDocument, sCannotInitializePulseAudio, true, u"*"_ns);
+      }
+      break;
+  }
+}
+
+void DecoderDoctorDiagnostics::StoreDecodeError(dom::Document* aDocument,
+                                                const MediaResult& aError,
+                                                const nsString& aMediaSrc,
+                                                const char* aCallSite) {
+  MOZ_ASSERT(NS_IsMainThread());
+  // Make sure we only store once.
+  MOZ_ASSERT(mDiagnosticsType == eUnsaved);
+  mDiagnosticsType = eDecodeError;
+
+  if (NS_WARN_IF(aError.Message().Length() > 2048)) {
+    DD_WARN(
+        "DecoderDoctorDiagnostics[%p]::StoreDecodeError(Document* "
+        "aDocument=%p, aError= TOO LONG! '%s', aMediaSrc=<provided>, call site "
+        "'%s')",
+        aDocument, this, aError.Description().get(), aCallSite);
+    return;
+  }
+
+  if (NS_WARN_IF(aMediaSrc.Length() > 2048)) {
+    DD_WARN(
+        "DecoderDoctorDiagnostics[%p]::StoreDecodeError(Document* "
+        "aDocument=%p, aError=%s, aMediaSrc= TOO LONG! <provided>, call site "
+        "'%s')",
+        aDocument, this, aError.Description().get(), aCallSite);
+    return;
+  }
+
+  if (NS_WARN_IF(!aDocument)) {
+    DD_WARN(
+        "DecoderDoctorDiagnostics[%p]::StoreDecodeError("
+        "Document* aDocument=nullptr, aError=%s,"
+        " aMediaSrc=<provided>, call site '%s')",
+        this, aError.Description().get(), aCallSite);
+    return;
+  }
+
+  RefPtr<DecoderDoctorDocumentWatcher> watcher =
+      DecoderDoctorDocumentWatcher::RetrieveOrCreate(aDocument);
+
+  if (NS_WARN_IF(!watcher)) {
+    DD_WARN(
+        "DecoderDoctorDiagnostics[%p]::StoreDecodeError("
+        "Document* aDocument=%p, aError='%s', aMediaSrc=<provided>,"
+        " call site '%s') - Could not create document watcher",
+        this, aDocument, aError.Description().get(), aCallSite);
+    return;
+  }
+
+  mDecodeIssue = aError;
+  mDecodeIssueMediaSrc = aMediaSrc;
+
+  // StoreDecodeError should only be called once, after all data is
+  // available, so it is safe to std::move() from this object.
+  watcher->AddDiagnostics(std::move(*this), aCallSite);
+  // Even though it's moved-from, the type should stay set
+  // (Only used to ensure that we do store only once.)
+  MOZ_ASSERT(mDiagnosticsType == eDecodeError);
+}
+
+void DecoderDoctorDiagnostics::StoreDecodeWarning(dom::Document* aDocument,
+                                                  const MediaResult& aWarning,
+                                                  const nsString& aMediaSrc,
+                                                  const char* aCallSite) {
+  MOZ_ASSERT(NS_IsMainThread());
+  // Make sure we only store once.
+  MOZ_ASSERT(mDiagnosticsType == eUnsaved);
+  mDiagnosticsType = eDecodeWarning;
+
+  if (NS_WARN_IF(!aDocument)) {
+    DD_WARN(
+        "DecoderDoctorDiagnostics[%p]::StoreDecodeWarning("
+        "Document* aDocument=nullptr, aWarning=%s,"
+        " aMediaSrc=<provided>, call site '%s')",
+        this, aWarning.Description().get(), aCallSite);
+    return;
+  }
+
+  RefPtr<DecoderDoctorDocumentWatcher> watcher =
+      DecoderDoctorDocumentWatcher::RetrieveOrCreate(aDocument);
+
+  if (NS_WARN_IF(!watcher)) {
+    DD_WARN(
+        "DecoderDoctorDiagnostics[%p]::StoreDecodeWarning("
+        "Document* aDocument=%p, aWarning='%s', aMediaSrc=<provided>,"
+        " call site '%s') - Could not create document watcher",
+        this, aDocument, aWarning.Description().get(), aCallSite);
+    return;
+  }
+
+  mDecodeIssue = aWarning;
+  mDecodeIssueMediaSrc = aMediaSrc;
+
+  // StoreDecodeWarning should only be called once, after all data is
+  // available, so it is safe to std::move() from this object.
+  watcher->AddDiagnostics(std::move(*this), aCallSite);
+  // Even though it's moved-from, the type should stay set
+  // (Only used to ensure that we do store only once.)
+  MOZ_ASSERT(mDiagnosticsType == eDecodeWarning);
+}
+
+static const char* EventDomainString(DecoderDoctorEvent::Domain aDomain) {
+  switch (aDomain) {
+    case DecoderDoctorEvent::eAudioSinkStartup:
+      return "audio-sink-startup";
+  }
+  return "?";
+}
+
+nsCString DecoderDoctorDiagnostics::GetDescription() const {
+  nsCString s;
+  switch (mDiagnosticsType) {
+    case eUnsaved:
+      s = "Unsaved diagnostics, cannot get accurate description";
+      break;
+    case eFormatSupportCheck:
+      s = "format='";
+      s += NS_ConvertUTF16toUTF8(mFormat).get();
+      s += mFlags.contains(Flags::CanPlay) ? "', can play" : "', cannot play";
+      if (mFlags.contains(Flags::VideoNotSupported)) {
+        s += ", but video format not supported";
+      }
+      if (mFlags.contains(Flags::AudioNotSupported)) {
+        s += ", but audio format not supported";
+      }
+      if (mFlags.contains(Flags::WMFFailedToLoad)) {
+        s += ", Windows platform decoder failed to load";
+      }
+      if (mFlags.contains(Flags::FFmpegNotFound)) {
+        s += ", Linux platform decoder not found";
+      }
+      if (mFlags.contains(Flags::GMPPDMFailedToStartup)) {
+        s += ", GMP PDM failed to startup";
+      } else if (!mGMP.IsEmpty()) {
+        s += ", Using GMP '";
+        s += mGMP;
+        s += "'";
+      }
+      break;
+    case eMediaKeySystemAccessRequest:
+      s = "key system='";
+      s += NS_ConvertUTF16toUTF8(mKeySystem).get();
+      s += mIsKeySystemSupported ? "', supported" : "', not supported";
+      switch (mKeySystemIssue) {
+        case eUnset:
+          break;
+        case eWidevineWithNoWMF:
+          s += ", Widevine with no WMF";
+          break;
+      }
+      break;
+    case eEvent:
+      s = nsPrintfCString("event domain %s result=%" PRIu32,
+                          EventDomainString(mEvent.mDomain),
+                          static_cast<uint32_t>(mEvent.mResult));
+      break;
+    case eDecodeError:
+      s = "decode error: ";
+      s += mDecodeIssue.Description();
+      s += ", src='";
+      s += mDecodeIssueMediaSrc.IsEmpty() ? "<none>" : "<provided>";
+      s += "'";
+      break;
+    case eDecodeWarning:
+      s = "decode warning: ";
+      s += mDecodeIssue.Description();
+      s += ", src='";
+      s += mDecodeIssueMediaSrc.IsEmpty() ? "<none>" : "<provided>";
+      s += "'";
+      break;
+    default:
+      MOZ_ASSERT_UNREACHABLE("Unexpected DiagnosticsType");
+      s = "?";
+      break;
+  }
+  return s;
+}
+
+static const char* ToDecoderDoctorReportTypeStr(
+    const dom::DecoderDoctorReportType& aType) {
+  switch (aType) {
+    case dom::DecoderDoctorReportType::Mediawidevinenowmf:
+      return sMediaWidevineNoWMF.mReportStringId;
+    case dom::DecoderDoctorReportType::Mediawmfneeded:
+      return sMediaWMFNeeded.mReportStringId;
+    case dom::DecoderDoctorReportType::Mediaplatformdecodernotfound:
+      return sMediaFFMpegNotFound.mReportStringId;
+    case dom::DecoderDoctorReportType::Mediacannotplaynodecoders:
+      return sMediaCannotPlayNoDecoders.mReportStringId;
+    case dom::DecoderDoctorReportType::Medianodecoders:
+      return sMediaNoDecoders.mReportStringId;
+    case dom::DecoderDoctorReportType::Mediacannotinitializepulseaudio:
+      return sCannotInitializePulseAudio.mReportStringId;
+    case dom::DecoderDoctorReportType::Mediaunsupportedlibavcodec:
+      return sUnsupportedLibavcodec.mReportStringId;
+    case dom::DecoderDoctorReportType::Mediadecodeerror:
+      return sMediaDecodeError.mReportStringId;
+    case dom::DecoderDoctorReportType::Mediadecodewarning:
+      return sMediaDecodeWarning.mReportStringId;
+    default:
+      DD_DEBUG("Invalid report type to str");
+      return "invalid-report-type";
+  }
+}
+
+void DecoderDoctorDiagnostics::SetDecoderDoctorReportType(
+    const dom::DecoderDoctorReportType& aType) {
+  DD_INFO("Set report type %s", ToDecoderDoctorReportTypeStr(aType));
+  switch (aType) {
+    case dom::DecoderDoctorReportType::Mediawmfneeded:
+      SetWMFFailedToLoad();
+      return;
+    case dom::DecoderDoctorReportType::Mediaplatformdecodernotfound:
+      SetFFmpegNotFound();
+      return;
+    case dom::DecoderDoctorReportType::Mediaunsupportedlibavcodec:
+      SetLibAVCodecUnsupported();
+      return;
+    case dom::DecoderDoctorReportType::Mediacannotplaynodecoders:
+    case dom::DecoderDoctorReportType::Medianodecoders:
+      // Do nothing, because these type are related with can-play, which would
+      // be handled in `StoreFormatDiagnostics()` when sending `false` in the
+      // parameter for the canplay.
+      return;
+    default:
+      DD_DEBUG("Not supported type");
+      return;
+  }
+}
+
+}  // namespace mozilla