--- a/dom/html/HTMLMediaElement.cpp
+++ b/dom/html/HTMLMediaElement.cpp
@@ -2461,17 +2461,18 @@ nsresult HTMLMediaElement::LoadResource(
ReportLoadError("MediaLoadInvalidURI", params, ArrayLength(params));
return rv;
}
SetupSrcMediaStreamPlayback(stream);
return NS_OK;
}
if (mMediaSource) {
- RefPtr<MediaSourceDecoder> decoder = new MediaSourceDecoder(this);
+ MediaDecoderInit decoderInit(this);
+ RefPtr<MediaSourceDecoder> decoder = new MediaSourceDecoder(decoderInit);
if (!mMediaSource->Attach(decoder)) {
// TODO: Handle failure: run "If the media data cannot be fetched at
// all, due to network errors, causing the user agent to give up
// trying to fetch the resource" section of resource fetch algorithm.
decoder->Shutdown();
return NS_ERROR_FAILURE;
}
ChangeDelayLoadStatus(false);
@@ -4589,17 +4590,19 @@ HTMLMediaElement::CanPlayType(const nsAS
nsresult HTMLMediaElement::InitializeDecoderAsClone(MediaDecoder* aOriginal)
{
NS_ASSERTION(mLoadingSrc, "mLoadingSrc must already be set");
NS_ASSERTION(mDecoder == nullptr, "Shouldn't have a decoder");
MediaResource* originalResource = aOriginal->GetResource();
if (!originalResource)
return NS_ERROR_FAILURE;
- RefPtr<MediaDecoder> decoder = aOriginal->Clone(this);
+
+ MediaDecoderInit decoderInit(this);
+ RefPtr<MediaDecoder> decoder = aOriginal->Clone(decoderInit);
if (!decoder)
return NS_ERROR_FAILURE;
LOG(LogLevel::Debug, ("%p Cloned decoder %p from %p", this, decoder.get(), aOriginal));
RefPtr<MediaResource> resource =
originalResource->CloneData(decoder->GetResourceCallback());
@@ -4618,18 +4621,19 @@ nsresult HTMLMediaElement::InitializeDec
NS_ASSERTION(mLoadingSrc, "mLoadingSrc must already be set");
nsAutoCString mimeType;
aChannel->GetContentType(mimeType);
NS_ASSERTION(!mimeType.IsEmpty(), "We should have the Content-Type.");
DecoderDoctorDiagnostics diagnostics;
+ MediaDecoderInit decoderInit(this);
RefPtr<MediaDecoder> decoder =
- DecoderTraits::CreateDecoder(mimeType, this, &diagnostics);
+ DecoderTraits::CreateDecoder(mimeType, decoderInit, &diagnostics);
diagnostics.StoreFormatDiagnostics(OwnerDoc(),
NS_ConvertASCIItoUTF16(mimeType),
decoder != nullptr,
__func__);
if (!decoder) {
nsAutoString src;
GetCurrentSrc(src);
NS_ConvertUTF8toUTF16 mimeUTF16(mimeType);
--- a/dom/media/ADTSDecoder.cpp
+++ b/dom/media/ADTSDecoder.cpp
@@ -9,22 +9,22 @@
#include "MediaContainerType.h"
#include "MediaDecoderStateMachine.h"
#include "MediaFormatReader.h"
#include "PDMFactory.h"
namespace mozilla {
MediaDecoder*
-ADTSDecoder::Clone(MediaDecoderOwner* aOwner)
+ADTSDecoder::Clone(MediaDecoderInit& aInit)
{
if (!IsEnabled())
return nullptr;
- return new ADTSDecoder(aOwner);
+ return new ADTSDecoder(aInit);
}
MediaDecoderStateMachine*
ADTSDecoder::CreateStateMachine()
{
RefPtr<MediaDecoderReader> reader =
new MediaFormatReader(this, new ADTSDemuxer(GetResource()));
return new MediaDecoderStateMachine(this, reader);
--- a/dom/media/ADTSDecoder.h
+++ b/dom/media/ADTSDecoder.h
@@ -12,18 +12,18 @@
namespace mozilla {
class MediaContainerType;
class ADTSDecoder : public MediaDecoder
{
public:
// MediaDecoder interface.
- explicit ADTSDecoder(MediaDecoderOwner* aOwner) : MediaDecoder(aOwner) {}
- MediaDecoder* Clone(MediaDecoderOwner* aOwner) override;
+ explicit ADTSDecoder(MediaDecoderInit& aInit) : MediaDecoder(aInit) {}
+ MediaDecoder* Clone(MediaDecoderInit& aInit) override;
MediaDecoderStateMachine* CreateStateMachine() override;
// Returns true if the ADTS backend is pref'ed on, and we're running on a
// platform that is likely to have decoders for the format.
static bool IsEnabled();
static bool IsSupportedType(const MediaContainerType& aContainerType);
};
--- a/dom/media/DecoderTraits.cpp
+++ b/dom/media/DecoderTraits.cpp
@@ -252,81 +252,81 @@ bool DecoderTraits::ShouldHandleMediaTyp
return CanHandleMediaType(*containerType, aDiagnostics) != CANPLAY_NO;
}
// Instantiates but does not initialize decoder.
static
already_AddRefed<MediaDecoder>
InstantiateDecoder(const MediaContainerType& aType,
- MediaDecoderOwner* aOwner,
+ MediaDecoderInit& aInit,
DecoderDoctorDiagnostics* aDiagnostics)
{
MOZ_ASSERT(NS_IsMainThread());
RefPtr<MediaDecoder> decoder;
#ifdef MOZ_FMP4
if (MP4Decoder::IsSupportedType(aType, aDiagnostics)) {
- decoder = new MP4Decoder(aOwner);
+ decoder = new MP4Decoder(aInit);
return decoder.forget();
}
#endif
if (MP3Decoder::IsSupportedType(aType)) {
- decoder = new MP3Decoder(aOwner);
+ decoder = new MP3Decoder(aInit);
return decoder.forget();
}
if (ADTSDecoder::IsSupportedType(aType)) {
- decoder = new ADTSDecoder(aOwner);
+ decoder = new ADTSDecoder(aInit);
return decoder.forget();
}
if (OggDecoder::IsSupportedType(aType)) {
- decoder = new OggDecoder(aOwner);
+ decoder = new OggDecoder(aInit);
return decoder.forget();
}
if (WaveDecoder::IsSupportedType(aType)) {
- decoder = new WaveDecoder(aOwner);
+ decoder = new WaveDecoder(aInit);
return decoder.forget();
}
if (FlacDecoder::IsSupportedType(aType)) {
- decoder = new FlacDecoder(aOwner);
+ decoder = new FlacDecoder(aInit);
return decoder.forget();
}
#ifdef MOZ_ANDROID_OMX
if (MediaDecoder::IsAndroidMediaPluginEnabled() &&
EnsureAndroidMediaPluginHost()->FindDecoder(aType, nullptr)) {
- decoder = new AndroidMediaDecoder(aOwner, aType);
+ decoder = new AndroidMediaDecoder(aInit, aType);
return decoder.forget();
}
#endif
if (WebMDecoder::IsSupportedType(aType)) {
- decoder = new WebMDecoder(aOwner);
+ decoder = new WebMDecoder(aInit);
return decoder.forget();
}
if (IsHttpLiveStreamingType(aType)) {
// We don't have an HLS decoder.
Telemetry::Accumulate(Telemetry::MEDIA_HLS_DECODER_SUCCESS, false);
}
return nullptr;
}
/* static */
already_AddRefed<MediaDecoder>
DecoderTraits::CreateDecoder(const nsACString& aType,
- MediaDecoderOwner* aOwner,
+ MediaDecoderInit& aInit,
DecoderDoctorDiagnostics* aDiagnostics)
{
MOZ_ASSERT(NS_IsMainThread());
Maybe<MediaContainerType> type = MakeMediaContainerType(aType);
if (!type) {
return nullptr;
}
- return InstantiateDecoder(*type, aOwner, aDiagnostics);
+ return InstantiateDecoder(*type, aInit, aDiagnostics);
}
/* static */
MediaDecoderReader*
DecoderTraits::CreateReader(const MediaContainerType& aType,
AbstractMediaDecoder* aDecoder)
{
MOZ_ASSERT(NS_IsMainThread());
--- a/dom/media/DecoderTraits.h
+++ b/dom/media/DecoderTraits.h
@@ -13,16 +13,17 @@ class nsAString;
class nsACString;
namespace mozilla {
class AbstractMediaDecoder;
class DecoderDoctorDiagnostics;
class MediaContainerType;
class MediaDecoder;
+struct MediaDecoderInit;
class MediaDecoderOwner;
class MediaDecoderReader;
enum CanPlayStatus {
CANPLAY_NO,
CANPLAY_MAYBE,
CANPLAY_YES
};
@@ -38,17 +39,17 @@ public:
// for the type is more limited than appears in the wild, we should return
// false here even if CanHandleMediaType would return true.
static bool ShouldHandleMediaType(const char* aMIMEType,
DecoderDoctorDiagnostics* aDiagnostics);
// Create a decoder for the given aType. Returns null if we
// were unable to create the decoder.
static already_AddRefed<MediaDecoder> CreateDecoder(const nsACString& aType,
- MediaDecoderOwner* aOwner,
+ MediaDecoderInit& aInit,
DecoderDoctorDiagnostics* aDiagnostics);
// Create a reader for thew given MIME type aType. Returns null
// if we were unable to create the reader.
static MediaDecoderReader* CreateReader(const MediaContainerType& aType,
AbstractMediaDecoder* aDecoder);
// Returns true if MIME type aType is supported in video documents,
--- a/dom/media/MP3Decoder.cpp
+++ b/dom/media/MP3Decoder.cpp
@@ -10,21 +10,21 @@
#include "MediaDecoderStateMachine.h"
#include "MediaFormatReader.h"
#include "MP3Demuxer.h"
#include "PDMFactory.h"
namespace mozilla {
MediaDecoder*
-MP3Decoder::Clone(MediaDecoderOwner* aOwner) {
+MP3Decoder::Clone(MediaDecoderInit& aInit) {
if (!IsEnabled()) {
return nullptr;
}
- return new MP3Decoder(aOwner);
+ return new MP3Decoder(aInit);
}
MediaDecoderStateMachine*
MP3Decoder::CreateStateMachine() {
RefPtr<MediaDecoderReader> reader =
new MediaFormatReader(this, new mp3::MP3Demuxer(GetResource()));
return new MediaDecoderStateMachine(this, reader);
}
--- a/dom/media/MP3Decoder.h
+++ b/dom/media/MP3Decoder.h
@@ -11,18 +11,18 @@
namespace mozilla {
class MediaContainerType;
class MP3Decoder : public MediaDecoder
{
public:
// MediaDecoder interface.
- explicit MP3Decoder(MediaDecoderOwner* aOwner) : MediaDecoder(aOwner) {}
- MediaDecoder* Clone(MediaDecoderOwner* aOwner) override;
+ explicit MP3Decoder(MediaDecoderInit& aInit) : MediaDecoder(aInit) {}
+ MediaDecoder* Clone(MediaDecoderInit& aInit) override;
MediaDecoderStateMachine* CreateStateMachine() override;
// Returns true if the MP3 backend is preffed on, and we're running on a
// platform that is likely to have decoders for the format.
static bool IsEnabled();
static bool IsSupportedType(const MediaContainerType& aContainerType);
};
--- a/dom/media/MediaDecoder.cpp
+++ b/dom/media/MediaDecoder.cpp
@@ -361,32 +361,32 @@ MediaDecoder::SetInfinite(bool aInfinite
bool
MediaDecoder::IsInfinite() const
{
MOZ_ASSERT(NS_IsMainThread());
return mInfiniteStream;
}
#define INIT_MIRROR(name, val) \
- name(aOwner->AbstractMainThread(), val, "MediaDecoder::" #name " (Mirror)")
+ name(mOwner->AbstractMainThread(), val, "MediaDecoder::" #name " (Mirror)")
#define INIT_CANONICAL(name, val) \
- name(aOwner->AbstractMainThread(), val, "MediaDecoder::" #name " (Canonical)")
+ name(mOwner->AbstractMainThread(), val, "MediaDecoder::" #name " (Canonical)")
-MediaDecoder::MediaDecoder(MediaDecoderOwner* aOwner)
- : mWatchManager(this, aOwner->AbstractMainThread())
+MediaDecoder::MediaDecoder(MediaDecoderInit& aInit)
+ : mWatchManager(this, aInit.mOwner->AbstractMainThread())
, mLogicalPosition(0.0)
, mDuration(std::numeric_limits<double>::quiet_NaN())
- , mResourceCallback(new ResourceCallback(aOwner->AbstractMainThread()))
+ , mResourceCallback(new ResourceCallback(aInit.mOwner->AbstractMainThread()))
, mCDMProxyPromise(mCDMProxyPromiseHolder.Ensure(__func__))
, mIgnoreProgressData(false)
, mInfiniteStream(false)
- , mOwner(aOwner)
- , mAbstractMainThread(aOwner->AbstractMainThread())
+ , mOwner(aInit.mOwner)
+ , mAbstractMainThread(aInit.mOwner->AbstractMainThread())
, mFrameStats(new FrameStatistics())
- , mVideoFrameContainer(aOwner->GetVideoFrameContainer())
+ , mVideoFrameContainer(aInit.mOwner->GetVideoFrameContainer())
, mPinnedForSeek(false)
, mMinimizePreroll(false)
, mFiredMetadataLoaded(false)
, mIsDocumentVisible(false)
, mElementVisibility(Visibility::UNTRACKED)
, mIsElementInTree(false)
, mForcedHidden(false)
, mHasSuspendTaint(false)
@@ -404,18 +404,18 @@ MediaDecoder::MediaDecoder(MediaDecoderO
, INIT_CANONICAL(mNextState, PLAY_STATE_PAUSED)
, INIT_CANONICAL(mLogicallySeeking, false)
, INIT_CANONICAL(mSameOriginMedia, false)
, INIT_CANONICAL(mMediaPrincipalHandle, PRINCIPAL_HANDLE_NONE)
, INIT_CANONICAL(mPlaybackBytesPerSecond, 0.0)
, INIT_CANONICAL(mPlaybackRateReliable, true)
, INIT_CANONICAL(mDecoderPosition, 0)
, mTelemetryReported(false)
- , mIsMediaElement(!!aOwner->GetMediaElement())
- , mElement(aOwner->GetMediaElement())
+ , mIsMediaElement(!!mOwner->GetMediaElement())
+ , mElement(mOwner->GetMediaElement())
{
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(mAbstractMainThread);
MediaMemoryTracker::AddMediaDecoder(this);
mAudioChannel = AudioChannelService::GetDefaultAudioChannel();
mResourceCallback->Connect(this);
--- a/dom/media/MediaDecoder.h
+++ b/dom/media/MediaDecoder.h
@@ -52,16 +52,26 @@ enum class MediaEventType : int8_t;
enum class Visibility : uint8_t;
// GetCurrentTime is defined in winbase.h as zero argument macro forwarding to
// GetTickCount() and conflicts with MediaDecoder::GetCurrentTime implementation.
#ifdef GetCurrentTime
#undef GetCurrentTime
#endif
+struct MediaDecoderInit
+{
+ MediaDecoderOwner* const mOwner;
+
+ explicit MediaDecoderInit(MediaDecoderOwner* aOwner)
+ : mOwner(aOwner)
+ {
+ }
+};
+
class MediaDecoder : public AbstractMediaDecoder
{
public:
// Used to register with MediaResource to receive notifications which will
// be forwarded to MediaDecoder.
class ResourceCallback : public MediaResourceCallback
{
// Throttle calls to MediaDecoder::NotifyDataArrived()
@@ -112,25 +122,25 @@ public:
PLAY_STATE_PLAYING,
PLAY_STATE_ENDED,
PLAY_STATE_SHUTDOWN
};
// Must be called exactly once, on the main thread, during startup.
static void InitStatics();
- explicit MediaDecoder(MediaDecoderOwner* aOwner);
+ explicit MediaDecoder(MediaDecoderInit& aInit);
// Return a callback object used to register with MediaResource to receive
// notifications.
MediaResourceCallback* GetResourceCallback() const;
// Create a new decoder of the same type as this one.
// Subclasses must implement this.
- virtual MediaDecoder* Clone(MediaDecoderOwner* aOwner) = 0;
+ virtual MediaDecoder* Clone(MediaDecoderInit& aInit) = 0;
// Create a new state machine to run this decoder.
// Subclasses must implement this.
virtual MediaDecoderStateMachine* CreateStateMachine() = 0;
// Cleanup internal data structures. Must be called on the main
// thread by the owning object before that object disposes of this object.
virtual void Shutdown();
--- a/dom/media/android/AndroidMediaDecoder.cpp
+++ b/dom/media/android/AndroidMediaDecoder.cpp
@@ -5,19 +5,19 @@
* You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "MediaDecoderStateMachine.h"
#include "AndroidMediaDecoder.h"
#include "AndroidMediaReader.h"
namespace mozilla {
-AndroidMediaDecoder::AndroidMediaDecoder(MediaDecoderOwner* aOwner,
+AndroidMediaDecoder::AndroidMediaDecoder(MediaDecoderInit& aInit,
const MediaContainerType& aType)
- : MediaDecoder(aOwner), mType(aType)
+ : MediaDecoder(aInit), mType(aType)
{
}
MediaDecoderStateMachine* AndroidMediaDecoder::CreateStateMachine()
{
return new MediaDecoderStateMachine(this, new AndroidMediaReader(this, mType));
}
--- a/dom/media/android/AndroidMediaDecoder.h
+++ b/dom/media/android/AndroidMediaDecoder.h
@@ -11,19 +11,19 @@
#include "MediaContainerType.h"
namespace mozilla {
class AndroidMediaDecoder : public MediaDecoder
{
MediaContainerType mType;
public:
- AndroidMediaDecoder(MediaDecoderOwner* aOwner, const MediaContainerType& aType);
+ AndroidMediaDecoder(MediaDecoderInit& aInit, const MediaContainerType& aType);
- MediaDecoder* Clone(MediaDecoderOwner* aOwner) override {
- return new AndroidMediaDecoder(aOwner, mType);
+ MediaDecoder* Clone(MediaDecoderInit& aInit) override {
+ return new AndroidMediaDecoder(aInit, mType);
}
MediaDecoderStateMachine* CreateStateMachine() override;
};
} // namespace mozilla
#endif
--- a/dom/media/flac/FlacDecoder.cpp
+++ b/dom/media/flac/FlacDecoder.cpp
@@ -9,23 +9,23 @@
#include "MediaContainerType.h"
#include "MediaDecoderStateMachine.h"
#include "MediaFormatReader.h"
#include "MediaPrefs.h"
namespace mozilla {
MediaDecoder*
-FlacDecoder::Clone(MediaDecoderOwner* aOwner)
+FlacDecoder::Clone(MediaDecoderInit& aInit)
{
if (!IsEnabled()) {
return nullptr;
}
- return new FlacDecoder(aOwner);
+ return new FlacDecoder(aInit);
}
MediaDecoderStateMachine*
FlacDecoder::CreateStateMachine()
{
RefPtr<MediaDecoderReader> reader =
new MediaFormatReader(this, new FlacDemuxer(GetResource()));
return new MediaDecoderStateMachine(this, reader);
--- a/dom/media/flac/FlacDecoder.h
+++ b/dom/media/flac/FlacDecoder.h
@@ -12,18 +12,18 @@
namespace mozilla {
class MediaContainerType;
class FlacDecoder : public MediaDecoder
{
public:
// MediaDecoder interface.
- explicit FlacDecoder(MediaDecoderOwner* aOwner) : MediaDecoder(aOwner) {}
- MediaDecoder* Clone(MediaDecoderOwner* aOwner) override;
+ explicit FlacDecoder(MediaDecoderInit& aInit) : MediaDecoder(aInit) {}
+ MediaDecoder* Clone(MediaDecoderInit& aInit) override;
MediaDecoderStateMachine* CreateStateMachine() override;
// Returns true if the Flac backend is pref'ed on, and we're running on a
// platform that is likely to have decoders for the format.
static bool IsEnabled();
static bool IsSupportedType(const MediaContainerType& aContainerType);
};
--- a/dom/media/fmp4/MP4Decoder.cpp
+++ b/dom/media/fmp4/MP4Decoder.cpp
@@ -20,18 +20,18 @@
#include "nsIGfxInfo.h"
#endif
#include "mozilla/layers/LayersTypes.h"
#include "PDMFactory.h"
namespace mozilla {
-MP4Decoder::MP4Decoder(MediaDecoderOwner* aOwner)
- : MediaDecoder(aOwner)
+MP4Decoder::MP4Decoder(MediaDecoderInit& aInit)
+ : MediaDecoder(aInit)
{
}
MediaDecoderStateMachine* MP4Decoder::CreateStateMachine()
{
mReader =
new MediaFormatReader(this,
new MP4Demuxer(GetResource()),
--- a/dom/media/fmp4/MP4Decoder.h
+++ b/dom/media/fmp4/MP4Decoder.h
@@ -14,23 +14,23 @@
namespace mozilla {
class MediaContainerType;
// Decoder that uses a bundled MP4 demuxer and platform decoders to play MP4.
class MP4Decoder : public MediaDecoder
{
public:
- explicit MP4Decoder(MediaDecoderOwner* aOwner);
+ explicit MP4Decoder(MediaDecoderInit& aInit);
- MediaDecoder* Clone(MediaDecoderOwner* aOwner) override {
+ MediaDecoder* Clone(MediaDecoderInit& aInit) override {
if (!IsEnabled()) {
return nullptr;
}
- return new MP4Decoder(aOwner);
+ return new MP4Decoder(aInit);
}
MediaDecoderStateMachine* CreateStateMachine() override;
// Returns true if aContainerType is an MP4 type that we think we can render
// with the a platform decoder backend.
// If provided, codecs are checked for support.
static bool IsSupportedType(const MediaContainerType& aContainerType,
--- a/dom/media/mediasource/MediaSourceDecoder.cpp
+++ b/dom/media/mediasource/MediaSourceDecoder.cpp
@@ -21,26 +21,26 @@ extern mozilla::LogModule* GetMediaSourc
#define MSE_DEBUG(arg, ...) MOZ_LOG(GetMediaSourceLog(), mozilla::LogLevel::Debug, ("MediaSourceDecoder(%p)::%s: " arg, this, __func__, ##__VA_ARGS__))
#define MSE_DEBUGV(arg, ...) MOZ_LOG(GetMediaSourceLog(), mozilla::LogLevel::Verbose, ("MediaSourceDecoder(%p)::%s: " arg, this, __func__, ##__VA_ARGS__))
using namespace mozilla::media;
namespace mozilla {
-MediaSourceDecoder::MediaSourceDecoder(dom::HTMLMediaElement* aElement)
- : MediaDecoder(aElement)
+MediaSourceDecoder::MediaSourceDecoder(MediaDecoderInit& aInit)
+ : MediaDecoder(aInit)
, mMediaSource(nullptr)
, mEnded(false)
{
mExplicitDuration.Set(Some(UnspecifiedNaN<double>()));
}
MediaDecoder*
-MediaSourceDecoder::Clone(MediaDecoderOwner* aOwner)
+MediaSourceDecoder::Clone(MediaDecoderInit& aInit)
{
// TODO: Sort out cloning.
return nullptr;
}
MediaDecoderStateMachine*
MediaSourceDecoder::CreateStateMachine()
{
--- a/dom/media/mediasource/MediaSourceDecoder.h
+++ b/dom/media/mediasource/MediaSourceDecoder.h
@@ -30,19 +30,19 @@ namespace dom {
class HTMLMediaElement;
class MediaSource;
} // namespace dom
class MediaSourceDecoder : public MediaDecoder
{
public:
- explicit MediaSourceDecoder(dom::HTMLMediaElement* aElement);
+ explicit MediaSourceDecoder(MediaDecoderInit& aInit);
- MediaDecoder* Clone(MediaDecoderOwner* aOwner) override;
+ MediaDecoder* Clone(MediaDecoderInit& aInit) override;
MediaDecoderStateMachine* CreateStateMachine() override;
nsresult Load(nsIStreamListener**) override;
media::TimeIntervals GetSeekable() override;
media::TimeIntervals GetBuffered() override;
void Shutdown() override;
static already_AddRefed<MediaResource> CreateResource(nsIPrincipal* aPrincipal = nullptr);
--- a/dom/media/ogg/OggDecoder.h
+++ b/dom/media/ogg/OggDecoder.h
@@ -10,27 +10,27 @@
namespace mozilla {
class MediaContainerType;
class OggDecoder : public MediaDecoder
{
public:
- explicit OggDecoder(MediaDecoderOwner* aOwner)
- : MediaDecoder(aOwner)
+ explicit OggDecoder(MediaDecoderInit& aInit)
+ : MediaDecoder(aInit)
, mShutdownBitMonitor("mShutdownBitMonitor")
, mShutdownBit(false)
{}
- MediaDecoder* Clone(MediaDecoderOwner* aOwner) override {
+ MediaDecoder* Clone(MediaDecoderInit& aInit) override {
if (!IsOggEnabled()) {
return nullptr;
}
- return new OggDecoder(aOwner);
+ return new OggDecoder(aInit);
}
MediaDecoderStateMachine* CreateStateMachine() override;
// For yucky legacy reasons, the ogg decoder needs to do a cross-thread read
// to check for shutdown while it hogs its own task queue. We don't want to
// protect the general state with a lock, so we make a special copy and a
// special-purpose lock. This method may be called on any thread.
bool IsOggDecoderShutdown() override
--- a/dom/media/wave/WaveDecoder.cpp
+++ b/dom/media/wave/WaveDecoder.cpp
@@ -9,19 +9,19 @@
#include "MediaDecoderStateMachine.h"
#include "WaveDecoder.h"
#include "MediaFormatReader.h"
#include "PDMFactory.h"
namespace mozilla {
MediaDecoder*
-WaveDecoder::Clone(MediaDecoderOwner* aOwner)
+WaveDecoder::Clone(MediaDecoderInit& aInit)
{
- return new WaveDecoder(aOwner);
+ return new WaveDecoder(aInit);
}
MediaDecoderStateMachine*
WaveDecoder::CreateStateMachine()
{
return new MediaDecoderStateMachine(
this, new MediaFormatReader(this, new WAVDemuxer(GetResource())));
}
--- a/dom/media/wave/WaveDecoder.h
+++ b/dom/media/wave/WaveDecoder.h
@@ -11,18 +11,18 @@
namespace mozilla {
class MediaContainerType;
class WaveDecoder : public MediaDecoder
{
public:
// MediaDecoder interface.
- explicit WaveDecoder(MediaDecoderOwner* aOwner) : MediaDecoder(aOwner) {}
- MediaDecoder* Clone(MediaDecoderOwner* aOwner) override;
+ explicit WaveDecoder(MediaDecoderInit& aInit) : MediaDecoder(aInit) {}
+ MediaDecoder* Clone(MediaDecoderInit& aInit) override;
MediaDecoderStateMachine* CreateStateMachine() override;
// Returns true if the Wave backend is pref'ed on, and we're running on a
// platform that is likely to have decoders for the format.
static bool IsSupportedType(const MediaContainerType& aContainerType);
};
} // namespace mozilla
--- a/dom/media/webm/WebMDecoder.h
+++ b/dom/media/webm/WebMDecoder.h
@@ -11,22 +11,22 @@
namespace mozilla {
class MediaContainerType;
class WebMDecoder : public MediaDecoder
{
public:
- explicit WebMDecoder(MediaDecoderOwner* aOwner) : MediaDecoder(aOwner) {}
- MediaDecoder* Clone(MediaDecoderOwner* aOwner) override {
+ explicit WebMDecoder(MediaDecoderInit& aInit) : MediaDecoder(aInit) {}
+ MediaDecoder* Clone(MediaDecoderInit& aInit) override {
if (!IsWebMEnabled()) {
return nullptr;
}
- return new WebMDecoder(aOwner);
+ return new WebMDecoder(aInit);
}
MediaDecoderStateMachine* CreateStateMachine() override;
// Returns true if aContainerType is a WebM type that we think we can render
// with an enabled platform decoder backend.
// If provided, codecs are checked for support.
static bool IsSupportedType(const MediaContainerType& aContainerType);