/* 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/Services.h"
#include "mozilla/StaticPrefs_media.h"
#include "mozilla/TimeStamp.h"
#include "mozilla/dom/Document.h"
#include "nsContentUtils.h"
#include "nsGkAtoms.h"
#include "nsIObserverService.h"
#include "nsIScriptError.h"
#include "nsITimer.h"
#include "nsPrintfCString.h"

#if defined(MOZ_FFMPEG)
#  include "FFmpegRuntimeLinker.h"
#endif

static mozilla::LazyLogModule sDecoderDoctorLog("DecoderDoctor");
#define DD_LOG(level, arg, ...) \
  MOZ_LOG_FMT(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={}) - Could not "
          "set property in document, will destroy new watcher[{}]",
          fmt::ptr(aDocument), fmt::ptr(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[{}]::DecoderDoctorDocumentWatcher(doc={})",
      fmt::ptr(this), fmt::ptr(mDocument));
}

DecoderDoctorDocumentWatcher::~DecoderDoctorDocumentWatcher() {
  MOZ_ASSERT(NS_IsMainThread());
  DD_DEBUG(
      "DecoderDoctorDocumentWatcher[{}, doc={} <- expect "
      "0]::~DecoderDoctorDocumentWatcher()",
      fmt::ptr(this), fmt::ptr(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[{}, "
      "doc={}]::RemovePropertyFromDocument()\n",
      fmt::ptr(watcher), fmt::ptr(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[{}, doc={}]::DestroyPropertyCallback()\n",
      fmt::ptr(watcher), fmt::ptr(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() {}",
           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={}) ReportToConsole"
      " - aMsg='{}' params={{{}{}{}{}}}",
      fmt::ptr(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()) {
    NS_DispatchToCurrentThread(NS_NewRunnableFunction(
        "mozreportmediaerror", [doc = RefPtr{aDocument}] {
          (void)nsContentUtils::DispatchTrustedEvent(
              doc, doc, u"mozreportmediaerror"_ns, CanBubble::eNo,
              Cancelable::eNo);
        }));
  }
  nsContentUtils::ReportToConsole(nsIScriptError::warningFlag, "Media"_ns,
                                  aDocument, PropertiesFile::DOM_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 '{}'!", 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 (auto mReportParam : aNotification.mReportParams) {
      if (mReportParam == ReportParam::None) {
        break;
      }
      switch (mReportParam) {
        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 {} (decodeResult={}) [AllowNotification={}, "
      "AllowDecodeIssue={}]",
      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[{}, doc={}]::SynthesizeAnalysis() - "
        "supported key systems '{}', playable formats '{}'; See if they show "
        "issues have been solved...",
        fmt::ptr(this), fmt::ptr(mDocument),
        NS_ConvertUTF16toUTF8(supportedKeySystems).get(),
        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[{}, "
                "doc={}]::SynthesizeAnalysis() - {} solved ('{}' now works, it "
                "was in pref({})='{}')",
                fmt::ptr(this), fmt::ptr(mDocument), id->mReportStringId,
                NS_ConvertUTF16toUTF8(workingFormat).get(), formatsPref.get(),
                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[{}, doc={}]::SynthesizeAnalysis() - "
            "{} not solved (pref({})='{}')",
            fmt::ptr(this), fmt::ptr(mDocument), id->mReportStringId,
            formatsPref.get(), 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[{}, doc={}]::SynthesizeAnalysis() - "
            "unsupported key systems: {}, Widevine without WMF",
            fmt::ptr(this), fmt::ptr(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[{}, doc={}]::SynthesizeAnalysis() - "
            "unplayable formats: {} -> Cannot play media because WMF was not "
            "found",
            fmt::ptr(this), fmt::ptr(mDocument),
            NS_ConvertUTF16toUTF8(formatsRequiringWMF).get());
        ReportAnalysis(mDocument, sMediaWMFNeeded, false, formatsRequiringWMF);
        return;
      }
      if (!formatsRequiringFFMpeg.IsEmpty()) {
        MOZ_DIAGNOSTIC_ASSERT(formatsLibAVCodecUnsupported.IsEmpty());
        DD_INFO(
            "DecoderDoctorDocumentWatcher[{}, "
            "doc={}]::SynthesizeAnalysis() - unplayable formats: {} -> "
            "Cannot play media because ffmpeg was not found (Reason: {})",
            fmt::ptr(this), fmt::ptr(mDocument),
            NS_ConvertUTF16toUTF8(formatsRequiringFFMpeg).get(),
            GetLinkStatusString());
        ReportAnalysis(mDocument, sMediaFFMpegNotFound, false,
                       formatsRequiringFFMpeg);
        return;
      }
      if (!formatsLibAVCodecUnsupported.IsEmpty()) {
        MOZ_DIAGNOSTIC_ASSERT(formatsRequiringFFMpeg.IsEmpty());
        DD_INFO(
            "DecoderDoctorDocumentWatcher[{}, "
            "doc={}]::SynthesizeAnalysis() - unplayable formats: {} -> "
            "Cannot play media because of unsupported {} (Reason: {})",
            fmt::ptr(this), fmt::ptr(mDocument),
            NS_ConvertUTF16toUTF8(formatsLibAVCodecUnsupported).get(),
            GetLinkStatusLibraryName(), GetLinkStatusString());
        ReportAnalysis(mDocument, sUnsupportedLibavcodec, false,
                       formatsLibAVCodecUnsupported);
        return;
      }
      DD_INFO(
          "DecoderDoctorDocumentWatcher[{}, doc={}]::SynthesizeAnalysis() - "
          "Cannot play media, unplayable formats: {}",
          fmt::ptr(this), fmt::ptr(mDocument),
          NS_ConvertUTF16toUTF8(unplayableFormats).get());
      ReportAnalysis(mDocument, sMediaCannotPlayNoDecoders, false,
                     unplayableFormats);
      return;
    }

    DD_INFO(
        "DecoderDoctorDocumentWatcher[{}, doc={}]::SynthesizeAnalysis() - Can "
        "play media, but no decoders for some requested formats: {}",
        fmt::ptr(this), fmt::ptr(mDocument),
        NS_ConvertUTF16toUTF8(unplayableFormats).get());
    if (Preferences::GetBool("media.decoder-doctor.verbose", false)) {
      ReportAnalysis(mDocument, sMediaNoDecoders, false, unplayableFormats);
    }
    return;
  }

  if (firstDecodeError) {
    DD_INFO(
        "DecoderDoctorDocumentWatcher[{}, doc={}]::SynthesizeAnalysis() - "
        "Decode error: {}",
        fmt::ptr(this), fmt::ptr(mDocument),
        firstDecodeError->Description().get());
    ReportAnalysis(mDocument, sMediaDecodeError, false, u""_ns,
                   *firstDecodeError,
                   true,  // aDecodeIssueIsError=true
                   mDocument->GetDocumentURI()->GetSpecOrDefault(),
                   *firstDecodeErrorMediaSrc);
    return;
  }

  if (firstDecodeWarning) {
    DD_INFO(
        "DecoderDoctorDocumentWatcher[{}, doc={}]::SynthesizeAnalysis() - "
        "Decode warning: {}",
        fmt::ptr(this), fmt::ptr(mDocument),
        firstDecodeWarning->Description().get());
    ReportAnalysis(mDocument, sMediaDecodeWarning, false, u""_ns,
                   *firstDecodeWarning,
                   false,  // aDecodeIssueIsError=false
                   mDocument->GetDocumentURI()->GetSpecOrDefault(),
                   *firstDecodeWarningMediaSrc);
    return;
  }

  DD_DEBUG(
      "DecoderDoctorDocumentWatcher[{}, doc={}]::SynthesizeAnalysis() - Can "
      "play media, decoders available for all requested formats",
      fmt::ptr(this), fmt::ptr(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[{}, "
      "doc={}]::AddDiagnostics(DecoderDoctorDiagnostics{{{}}}, call site '{}')",
      fmt::ptr(this), fmt::ptr(mDocument), aDiagnostics.GetDescription().get(),
      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[{}, doc={}]::Notify() - No new "
        "diagnostics to analyze -> Stop watching",
        fmt::ptr(this), fmt::ptr(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[{}]::StoreFormatDiagnostics(Document* "
        "aDocument={}, format= TOO LONG! '{}', can-play={}, call site '{}')",
        fmt::ptr(aDocument), fmt::ptr(this),
        NS_ConvertUTF16toUTF8(aFormat).get(), aCanPlay, aCallSite);
    return;
  }

  if (NS_WARN_IF(!aDocument)) {
    DD_WARN(
        "DecoderDoctorDiagnostics[{}]::StoreFormatDiagnostics(Document* "
        "aDocument=nullptr, format='{}', can-play={}, call site '{}')",
        fmt::ptr(this), NS_ConvertUTF16toUTF8(aFormat).get(), aCanPlay,
        aCallSite);
    return;
  }
  if (NS_WARN_IF(aFormat.IsEmpty())) {
    DD_WARN(
        "DecoderDoctorDiagnostics[{}]::StoreFormatDiagnostics(Document* "
        "aDocument={}, format=<empty>, can-play={}, call site '{}')",
        fmt::ptr(this), fmt::ptr(aDocument), aCanPlay, aCallSite);
    return;
  }

  RefPtr<DecoderDoctorDocumentWatcher> watcher =
      DecoderDoctorDocumentWatcher::RetrieveOrCreate(aDocument);

  if (NS_WARN_IF(!watcher)) {
    DD_WARN(
        "DecoderDoctorDiagnostics[{}]::StoreFormatDiagnostics(Document* "
        "aDocument={}, format='{}', can-play={}, call site '{}') - Could not "
        "create document watcher",
        fmt::ptr(this), fmt::ptr(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[{}]::StoreMediaKeySystemAccess(Document* "
        "aDocument={}, keysystem= TOO LONG! '{}', supported={}, call site "
        "'{}')",
        fmt::ptr(aDocument), fmt::ptr(this),
        NS_ConvertUTF16toUTF8(aKeySystem).get(), aIsSupported, aCallSite);
    return;
  }

  if (NS_WARN_IF(!aDocument)) {
    DD_WARN(
        "DecoderDoctorDiagnostics[{}]::StoreMediaKeySystemAccess(Document* "
        "aDocument=nullptr, keysystem='{}', supported={}, call site '{}')",
        fmt::ptr(this), NS_ConvertUTF16toUTF8(aKeySystem).get(), aIsSupported,
        aCallSite);
    return;
  }
  if (NS_WARN_IF(aKeySystem.IsEmpty())) {
    DD_WARN(
        "DecoderDoctorDiagnostics[{}]::StoreMediaKeySystemAccess(Document* "
        "aDocument={}, keysystem=<empty>, supported={}, call site '{}')",
        fmt::ptr(this), fmt::ptr(aDocument), aIsSupported, aCallSite);
    return;
  }

  RefPtr<DecoderDoctorDocumentWatcher> watcher =
      DecoderDoctorDocumentWatcher::RetrieveOrCreate(aDocument);

  if (NS_WARN_IF(!watcher)) {
    DD_WARN(
        "DecoderDoctorDiagnostics[{}]::StoreMediaKeySystemAccess(Document* "
        "aDocument={}, keysystem='{}', supported={}, call site '{}') - Could "
        "not create document watcher",
        fmt::ptr(this), fmt::ptr(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[{}]::StoreEvent(Document* "
        "aDocument=nullptr, aEvent={}, call site '{}')",
        fmt::ptr(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[{}, doc={}]::AddDiagnostics() - "
            "unable to initialize PulseAudio",
            fmt::ptr(this), fmt::ptr(aDocument));
        ReportAnalysis(aDocument, sCannotInitializePulseAudio, false, u"*"_ns);
      } else if (aEvent.mResult == NS_OK) {
        DD_INFO(
            "DecoderDoctorDocumentWatcher[{}, doc={}]::AddDiagnostics() - now "
            "able to initialize PulseAudio",
            fmt::ptr(this), fmt::ptr(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[{}]::StoreDecodeError(Document* "
        "aDocument={}, aError= TOO LONG! '{}', aMediaSrc=<provided>, call site "
        "'{}')",
        fmt::ptr(aDocument), fmt::ptr(this), aError.Description().get(),
        aCallSite);
    return;
  }

  if (NS_WARN_IF(aMediaSrc.Length() > 2048)) {
    DD_WARN(
        "DecoderDoctorDiagnostics[{}]::StoreDecodeError(Document* "
        "aDocument={}, aError={}, aMediaSrc= TOO LONG! <provided>, call site "
        "'{}')",
        fmt::ptr(aDocument), fmt::ptr(this), aError.Description().get(),
        aCallSite);
    return;
  }

  if (NS_WARN_IF(!aDocument)) {
    DD_WARN(
        "DecoderDoctorDiagnostics[{}]::StoreDecodeError("
        "Document* aDocument=nullptr, aError={},"
        " aMediaSrc=<provided>, call site '{}')",
        fmt::ptr(this), aError.Description().get(), aCallSite);
    return;
  }

  RefPtr<DecoderDoctorDocumentWatcher> watcher =
      DecoderDoctorDocumentWatcher::RetrieveOrCreate(aDocument);

  if (NS_WARN_IF(!watcher)) {
    DD_WARN(
        "DecoderDoctorDiagnostics[{}]::StoreDecodeError("
        "Document* aDocument={}, aError='{}', aMediaSrc=<provided>,"
        " call site '{}') - Could not create document watcher",
        fmt::ptr(this), fmt::ptr(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[{}]::StoreDecodeWarning("
        "Document* aDocument=nullptr, aWarning={},"
        " aMediaSrc=<provided>, call site '{}')",
        fmt::ptr(this), aWarning.Description().get(), aCallSite);
    return;
  }

  RefPtr<DecoderDoctorDocumentWatcher> watcher =
      DecoderDoctorDocumentWatcher::RetrieveOrCreate(aDocument);

  if (NS_WARN_IF(!watcher)) {
    DD_WARN(
        "DecoderDoctorDiagnostics[{}]::StoreDecodeWarning("
        "Document* aDocument={}, aWarning='{}', aMediaSrc=<provided>,"
        " call site '{}') - Could not create document watcher",
        fmt::ptr(this), fmt::ptr(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 {}", 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