PDMFactorySupport.h

Enable keyboard shortcuts

/* 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/. */

#if !defined(PDMFactorySupport_h_)

#  define PDMFactorySupport_h_

#  include "MediaCodecsSupport.h"

#  include "PDMFactory.h"

#  include "mozilla/RefPtr.h"

#  include "mozilla/StaticMutex.h"

#  include "nsStringFwd.h"

namespace mozilla {

class DecoderDoctorDiagnostics;

struct SupportDecoderParams;

// `PDMFactorySupport` is a process-wide cache of `PDMFactory` support

// queries. Use it whenever you only need to ask whether a mime type or

// decoder configuration is supported; it avoids constructing a fresh

// `PDMFactory` per call. Constructing a `PDMFactory` is expensive — it

// enumerates every available platform decoder module and logs their

// configuration — and that cost dominates query-only paths like

// `MediaSource.isTypeSupported`. Sharing a single `PDMFactory` across

// queries pays that cost once per process and reuses the result for every

// subsequent query, while pref and `gfxVar` listeners ensure the cached

// answer stays consistent with the current configuration. Decoder creation

// paths must continue to use `new PDMFactory()` directly because they

// depend on per-stream state.

//

// Used primarily in the content process, where the bulk of the

// `isTypeSupported` traffic originates. The RDD, GPU, and

// utility-media-service processes also reach this class indirectly via

// `PDMFactory::Supported()` when a `gfxVar` update arrives over IPC and

// they need to recompute their `MediaCodecsSupported` snapshot.

class PDMFactorySupport final {

 public:

  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(PDMFactorySupport)

  // Public query API. These resolve the singleton internally and return an

  // empty `DecodeSupportSet` (semantically "not supported") past

  // `AppShutdownConfirmed`.

  static media::DecodeSupportSet IsTypeSupported(const nsACString& aMimeType);

  static media::DecodeSupportSet IsSupported(

      const SupportDecoderParams& aParams,

      DecoderDoctorDiagnostics* aDiagnostics);

  // Singleton accessor. Thread-safe; lazily builds the cached factory on

  // first call. Returns null after `AppShutdownConfirmed`. Prefer the static

  // query methods above for query-only call sites; `Instance()` is exposed

  // mainly so gtests can exercise the singleton's lifecycle directly.

  static RefPtr<PDMFactorySupport> Instance();

  // Marks the singleton as stale so the next `Instance()` call rebuilds it.

  // Cheap, lock-free, callable from any thread.

  static void Invalidate();

 private:

  PDMFactorySupport();

  ~PDMFactorySupport() = default;

  media::DecodeSupportSet SupportsMimeType(const nsACString& aMimeType) const {

    return mFactory->SupportsMimeType(aMimeType);

  media::DecodeSupportSet Supports(

      const SupportDecoderParams& aParams,

      DecoderDoctorDiagnostics* aDiagnostics) const {

    return mFactory->Supports(aParams, aDiagnostics);

  static void EnsureInvalidationListenersRegistered(

      const StaticMutexAutoLock& aProofOfLock);

  static void OnInvalidatingPrefChanged(const char* aPref, void* aData);

  static void OnInvalidatingGfxVarChanged();

  const RefPtr<PDMFactory> mFactory;

};

}  // namespace mozilla

#endif  // PDMFactorySupport_h_