--- a/dom/html/HTMLMediaElement.cpp
+++ b/dom/html/HTMLMediaElement.cpp
@@ -236,41 +236,38 @@ RejectPromises(const nsTArray<RefPtr<Pro
class nsMediaEvent : public Runnable
{
public:
explicit nsMediaEvent(const char* aName, HTMLMediaElement* aElement)
: Runnable(aName)
, mElement(aElement)
, mLoadID(mElement->GetCurrentLoadID())
- {
- }
+ {}
~nsMediaEvent() {}
NS_IMETHOD Run() = 0;
protected:
- bool IsCancelled() {
- return mElement->GetCurrentLoadID() != mLoadID;
- }
+ bool IsCancelled() { return mElement->GetCurrentLoadID() != mLoadID; }
RefPtr<HTMLMediaElement> mElement;
uint32_t mLoadID;
};
class HTMLMediaElement::nsAsyncEventRunner : public nsMediaEvent
{
private:
nsString mName;
public:
- nsAsyncEventRunner(const nsAString& aName, HTMLMediaElement* aElement) :
- nsMediaEvent("HTMLMediaElement::nsAsyncEventRunner", aElement), mName(aName)
- {
- }
+ nsAsyncEventRunner(const nsAString& aName, HTMLMediaElement* aElement)
+ : nsMediaEvent("HTMLMediaElement::nsAsyncEventRunner", aElement)
+ , mName(aName)
+ {}
NS_IMETHOD Run() override
{
// Silently cancel if our load has been cancelled.
if (IsCancelled())
return NS_OK;
return mElement->DispatchEvent(mName);
@@ -282,28 +279,32 @@ public:
* resolve the passed promises with undefined; otherwise, the instance will
* reject the passed promises with the passed error.
*
* The constructor appends the constructed instance into the passed media
* element's mPendingPlayPromisesRunners member and once the the runner is run
* (whether fulfilled or canceled), it removes itself from
* mPendingPlayPromisesRunners.
*/
-class HTMLMediaElement::nsResolveOrRejectPendingPlayPromisesRunner : public nsMediaEvent
+class HTMLMediaElement::nsResolveOrRejectPendingPlayPromisesRunner
+ : public nsMediaEvent
{
nsTArray<RefPtr<Promise>> mPromises;
nsresult mError;
public:
- nsResolveOrRejectPendingPlayPromisesRunner(HTMLMediaElement* aElement,
- nsTArray<RefPtr<Promise>>&& aPromises,
- nsresult aError = NS_OK)
- : nsMediaEvent("HTMLMediaElement::nsResolveOrRejectPendingPlayPromisesRunner", aElement)
- , mPromises(Move(aPromises))
- , mError(aError)
+ nsResolveOrRejectPendingPlayPromisesRunner(
+ HTMLMediaElement* aElement,
+ nsTArray<RefPtr<Promise>>&& aPromises,
+ nsresult aError = NS_OK)
+ : nsMediaEvent(
+ "HTMLMediaElement::nsResolveOrRejectPendingPlayPromisesRunner",
+ aElement)
+ , mPromises(Move(aPromises))
+ , mError(aError)
{
mElement->mPendingPlayPromisesRunners.AppendElement(this);
}
void ResolveOrReject()
{
if (NS_SUCCEEDED(mError)) {
ResolvePromisesWithUndefined(mPromises);
@@ -318,25 +319,25 @@ public:
ResolveOrReject();
}
mElement->mPendingPlayPromisesRunners.RemoveElement(this);
return NS_OK;
}
};
-class HTMLMediaElement::nsNotifyAboutPlayingRunner : public nsResolveOrRejectPendingPlayPromisesRunner
+class HTMLMediaElement::nsNotifyAboutPlayingRunner
+ : public nsResolveOrRejectPendingPlayPromisesRunner
{
public:
nsNotifyAboutPlayingRunner(HTMLMediaElement* aElement,
nsTArray<RefPtr<Promise>>&& aPendingPlayPromises)
- : nsResolveOrRejectPendingPlayPromisesRunner(aElement,
- Move(aPendingPlayPromises))
- {
- }
+ : nsResolveOrRejectPendingPlayPromisesRunner(aElement,
+ Move(aPendingPlayPromises))
+ {}
NS_IMETHOD Run() override
{
if (IsCancelled()) {
mElement->mPendingPlayPromisesRunners.RemoveElement(this);
return NS_OK;
}
@@ -344,47 +345,47 @@ public:
return nsResolveOrRejectPendingPlayPromisesRunner::Run();
}
};
class nsSourceErrorEventRunner : public nsMediaEvent
{
private:
nsCOMPtr<nsIContent> mSource;
+
public:
- nsSourceErrorEventRunner(HTMLMediaElement* aElement,
- nsIContent* aSource)
- : nsMediaEvent("dom::nsSourceErrorEventRunner", aElement),
- mSource(aSource)
+ nsSourceErrorEventRunner(HTMLMediaElement* aElement, nsIContent* aSource)
+ : nsMediaEvent("dom::nsSourceErrorEventRunner", aElement)
+ , mSource(aSource)
+ {}
+
+ NS_IMETHOD Run() override
{
- }
-
- NS_IMETHOD Run() override {
// Silently cancel if our load has been cancelled.
if (IsCancelled())
return NS_OK;
- LOG_EVENT(LogLevel::Debug, ("%p Dispatching simple event source error", mElement.get()));
- return nsContentUtils::DispatchTrustedEvent(mElement->OwnerDoc(),
- mSource,
- NS_LITERAL_STRING("error"),
- false,
- false);
+ LOG_EVENT(LogLevel::Debug,
+ ("%p Dispatching simple event source error", mElement.get()));
+ return nsContentUtils::DispatchTrustedEvent(
+ mElement->OwnerDoc(), mSource, NS_LITERAL_STRING("error"), false, false);
}
};
/**
* This listener observes the first video frame to arrive with a non-empty size,
* and calls HTMLMediaElement::UpdateInitialMediaSize() with that size.
*/
-class HTMLMediaElement::StreamSizeListener : public DirectMediaStreamTrackListener {
+class HTMLMediaElement::StreamSizeListener
+ : public DirectMediaStreamTrackListener
+{
public:
- explicit StreamSizeListener(HTMLMediaElement* aElement) :
- mElement(aElement),
- mMainThreadEventTarget(aElement->MainThreadEventTarget()),
- mInitialSizeFound(false)
+ explicit StreamSizeListener(HTMLMediaElement* aElement)
+ : mElement(aElement)
+ , mMainThreadEventTarget(aElement->MainThreadEventTarget())
+ , mInitialSizeFound(false)
{
MOZ_ASSERT(mElement);
MOZ_ASSERT(mMainThreadEventTarget);
}
void Forget() { mElement = nullptr; }
void ReceivedSize(gfx::IntSize aSize)
@@ -409,17 +410,17 @@ public:
if (aMedia.GetType() != MediaSegment::VIDEO) {
MOZ_ASSERT(false, "Should only lock on to a video track");
return;
}
const VideoSegment& video = static_cast<const VideoSegment&>(aMedia);
for (VideoSegment::ConstChunkIterator c(video); !c.IsEnded(); c.Next()) {
- if (c->mFrame.GetIntrinsicSize() != gfx::IntSize(0,0)) {
+ if (c->mFrame.GetIntrinsicSize() != gfx::IntSize(0, 0)) {
mInitialSizeFound = true;
// This is fine to dispatch straight to main thread (instead of via
// ...AfterStreamUpdate()) since it reflects state of the element,
// not the stream. Events reflecting stream or track state should be
// dispatched so their order is preserved.
mMainThreadEventTarget->Dispatch(NewRunnableMethod<gfx::IntSize>(
"dom::HTMLMediaElement::StreamSizeListener::ReceivedSize",
this,
@@ -463,18 +464,18 @@ class HTMLMediaElement::MediaLoadListene
NS_DECL_NSISTREAMLISTENER
NS_DECL_NSICHANNELEVENTSINK
NS_DECL_NSIOBSERVER
NS_DECL_NSIINTERFACEREQUESTOR
NS_DECL_NSITHREADRETARGETABLESTREAMLISTENER
public:
explicit MediaLoadListener(HTMLMediaElement* aElement)
- : mElement(aElement),
- mLoadID(aElement->GetCurrentLoadID())
+ : mElement(aElement)
+ , mLoadID(aElement->GetCurrentLoadID())
{
MOZ_ASSERT(mElement, "Must pass an element to call back");
}
private:
RefPtr<HTMLMediaElement> mElement;
nsCOMPtr<nsIStreamListener> mNextListener;
const uint32_t mLoadID;
@@ -561,17 +562,18 @@ HTMLMediaElement::MediaLoadListener::OnS
element->GetCurrentSrc(src);
const char16_t* params[] = { code.get(), src.get() };
element->ReportLoadError("MediaLoadHttpError", params, ArrayLength(params));
return NS_BINDING_ABORTED;
}
nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest);
if (channel &&
- NS_SUCCEEDED(rv = element->InitializeDecoderForChannel(channel, getter_AddRefs(mNextListener))) &&
+ NS_SUCCEEDED(rv = element->InitializeDecoderForChannel(
+ channel, getter_AddRefs(mNextListener))) &&
mNextListener) {
rv = mNextListener->OnStartRequest(aRequest, aContext);
} else {
// If InitializeDecoderForChannel() returned an error, fire a network error.
if (NS_FAILED(rv) && !mNextListener) {
// Load failed, attempt to load the next candidate resource. If there
// are none, this will trigger a MEDIA_ERR_SRC_NOT_SUPPORTED error.
element->NotifyLoadError();
@@ -599,27 +601,30 @@ HTMLMediaElement::MediaLoadListener::OnS
NS_IMETHODIMP
HTMLMediaElement::MediaLoadListener::OnDataAvailable(nsIRequest* aRequest,
nsISupports* aContext,
nsIInputStream* aStream,
uint64_t aOffset,
uint32_t aCount)
{
if (!mNextListener) {
- NS_ERROR("Must have a chained listener; OnStartRequest should have canceled this request");
+ NS_ERROR("Must have a chained listener; OnStartRequest should have "
+ "canceled this request");
return NS_BINDING_ABORTED;
}
- return mNextListener->OnDataAvailable(aRequest, aContext, aStream, aOffset, aCount);
+ return mNextListener->OnDataAvailable(
+ aRequest, aContext, aStream, aOffset, aCount);
}
NS_IMETHODIMP
-HTMLMediaElement::MediaLoadListener::AsyncOnChannelRedirect(nsIChannel* aOldChannel,
- nsIChannel* aNewChannel,
- uint32_t aFlags,
- nsIAsyncVerifyRedirectCallback* cb)
+HTMLMediaElement::MediaLoadListener::AsyncOnChannelRedirect(
+ nsIChannel* aOldChannel,
+ nsIChannel* aNewChannel,
+ uint32_t aFlags,
+ nsIAsyncVerifyRedirectCallback* cb)
{
// TODO is this really correct?? See bug #579329.
if (mElement) {
mElement->OnChannelRedirect(aOldChannel, aNewChannel, aFlags);
}
nsCOMPtr<nsIChannelEventSink> sink = do_QueryInterface(mNextListener);
if (sink) {
return sink->AsyncOnChannelRedirect(aOldChannel, aNewChannel, aFlags, cb);
@@ -642,36 +647,38 @@ HTMLMediaElement::MediaLoadListener::Che
NS_IMETHODIMP
HTMLMediaElement::MediaLoadListener::GetInterface(const nsIID& aIID,
void** aResult)
{
return QueryInterface(aIID, aResult);
}
-void HTMLMediaElement::ReportLoadError(const char* aMsg,
- const char16_t** aParams,
- uint32_t aParamCount)
+void
+HTMLMediaElement::ReportLoadError(const char* aMsg,
+ const char16_t** aParams,
+ uint32_t aParamCount)
{
nsContentUtils::ReportToConsole(nsIScriptError::warningFlag,
NS_LITERAL_CSTRING("Media"),
OwnerDoc(),
nsContentUtils::eDOM_PROPERTIES,
aMsg,
aParams,
aParamCount);
}
-static bool IsAutoplayEnabled()
+static bool
+IsAutoplayEnabled()
{
return Preferences::GetBool("media.autoplay.enabled");
}
-class HTMLMediaElement::AudioChannelAgentCallback final :
- public nsIAudioChannelAgentCallback
+class HTMLMediaElement::AudioChannelAgentCallback final
+ : public nsIAudioChannelAgentCallback
{
public:
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
NS_DECL_CYCLE_COLLECTION_CLASS(AudioChannelAgentCallback)
explicit AudioChannelAgentCallback(HTMLMediaElement* aOwner)
: mOwner(aOwner)
, mAudioChannelVolume(1.0)
@@ -680,73 +687,73 @@ public:
, mSuspended(nsISuspendedTypes::NONE_SUSPENDED)
, mIsOwnerAudible(IsOwnerAudible())
, mIsShutDown(false)
{
MOZ_ASSERT(mOwner);
MaybeCreateAudioChannelAgent();
}
- void
- UpdateAudioChannelPlayingState(bool aForcePlaying = false)
+ void UpdateAudioChannelPlayingState(bool aForcePlaying = false)
{
MOZ_ASSERT(!mIsShutDown);
bool playingThroughTheAudioChannel =
aForcePlaying || IsPlayingThroughTheAudioChannel();
if (playingThroughTheAudioChannel != mPlayingThroughTheAudioChannel) {
if (!MaybeCreateAudioChannelAgent()) {
return;
}
mPlayingThroughTheAudioChannel = playingThroughTheAudioChannel;
NotifyAudioChannelAgent(mPlayingThroughTheAudioChannel);
}
}
- bool
- ShouldResetSuspend() const
+ bool ShouldResetSuspend() const
{
// The disposable-pause should be clear after media starts playing.
if (!mOwner->Paused() &&
mSuspended == nsISuspendedTypes::SUSPENDED_PAUSE_DISPOSABLE) {
return true;
}
// If the blocked media is paused, we don't need to resume it. We reset the
// mSuspended in order to unregister the agent.
- if (mOwner->Paused() &&
- mSuspended == nsISuspendedTypes::SUSPENDED_BLOCK) {
+ if (mOwner->Paused() && mSuspended == nsISuspendedTypes::SUSPENDED_BLOCK) {
return true;
}
return false;
}
- void
- NotifyPlayStateChanged()
+ void NotifyPlayStateChanged()
{
MOZ_ASSERT(!mIsShutDown);
if (ShouldResetSuspend()) {
SetSuspended(nsISuspendedTypes::NONE_SUSPENDED);
NotifyAudioPlaybackChanged(
AudioChannelService::AudibleChangedReasons::ePauseStateChanged);
}
UpdateAudioChannelPlayingState();
}
NS_IMETHODIMP
WindowVolumeChanged(float aVolume, bool aMuted) override
{
MOZ_ASSERT(mAudioChannelAgent);
- MOZ_LOG(AudioChannelService::GetAudioChannelLog(), LogLevel::Debug,
- ("HTMLMediaElement::AudioChannelAgentCallback, WindowVolumeChanged, "
- "this = %p, aVolume = %f, aMuted = %s\n",
- this, aVolume, aMuted ? "true" : "false"));
+ MOZ_LOG(
+ AudioChannelService::GetAudioChannelLog(),
+ LogLevel::Debug,
+ ("HTMLMediaElement::AudioChannelAgentCallback, WindowVolumeChanged, "
+ "this = %p, aVolume = %f, aMuted = %s\n",
+ this,
+ aVolume,
+ aMuted ? "true" : "false"));
if (mAudioChannelVolume != aVolume) {
mAudioChannelVolume = aVolume;
mOwner->SetVolumeInternal();
}
const uint32_t muted = mOwner->mMuted;
if (aMuted && !mOwner->ComputedMuted()) {
@@ -758,246 +765,248 @@ public:
return NS_OK;
}
NS_IMETHODIMP
WindowSuspendChanged(SuspendTypes aSuspend) override
{
MOZ_ASSERT(mAudioChannelAgent);
- MOZ_LOG(AudioChannelService::GetAudioChannelLog(), LogLevel::Debug,
- ("HTMLMediaElement::AudioChannelAgentCallback, WindowSuspendChanged, "
- "this = %p, aSuspend = %s\n", this, SuspendTypeToStr(aSuspend)));
+ MOZ_LOG(
+ AudioChannelService::GetAudioChannelLog(),
+ LogLevel::Debug,
+ ("HTMLMediaElement::AudioChannelAgentCallback, WindowSuspendChanged, "
+ "this = %p, aSuspend = %s\n",
+ this,
+ SuspendTypeToStr(aSuspend)));
switch (aSuspend) {
case nsISuspendedTypes::NONE_SUSPENDED:
Resume();
break;
case nsISuspendedTypes::SUSPENDED_PAUSE:
case nsISuspendedTypes::SUSPENDED_PAUSE_DISPOSABLE:
case nsISuspendedTypes::SUSPENDED_BLOCK:
Suspend(aSuspend);
break;
case nsISuspendedTypes::SUSPENDED_STOP_DISPOSABLE:
Stop();
break;
default:
- MOZ_LOG(AudioChannelService::GetAudioChannelLog(), LogLevel::Debug,
- ("HTMLMediaElement::AudioChannelAgentCallback, WindowSuspendChanged, "
- "this = %p, Error : unknown suspended type!\n", this));
+ MOZ_LOG(
+ AudioChannelService::GetAudioChannelLog(),
+ LogLevel::Debug,
+ ("HTMLMediaElement::AudioChannelAgentCallback, WindowSuspendChanged, "
+ "this = %p, Error : unknown suspended type!\n",
+ this));
}
return NS_OK;
}
NS_IMETHODIMP
WindowAudioCaptureChanged(bool aCapture) override
{
MOZ_ASSERT(mAudioChannelAgent);
if (mAudioCapturedByWindow != aCapture) {
mAudioCapturedByWindow = aCapture;
AudioCaptureStreamChangeIfNeeded();
}
return NS_OK;
}
- void
- AudioCaptureStreamChangeIfNeeded()
+ void AudioCaptureStreamChangeIfNeeded()
{
MOZ_ASSERT(!mIsShutDown);
if (!IsPlayingStarted()) {
return;
}
if (!mOwner->HasAudio()) {
return;
}
mOwner->AudioCaptureStreamChange(mAudioCapturedByWindow);
}
- void
- NotifyAudioPlaybackChanged(AudibleChangedReasons aReason)
+ void NotifyAudioPlaybackChanged(AudibleChangedReasons aReason)
{
MOZ_ASSERT(!mIsShutDown);
if (!IsPlayingStarted()) {
return;
}
AudibleState newAudibleState = IsOwnerAudible();
if (mIsOwnerAudible == newAudibleState) {
return;
}
mIsOwnerAudible = newAudibleState;
mAudioChannelAgent->NotifyStartedAudible(mIsOwnerAudible, aReason);
}
- bool
- IsPlaybackBlocked()
+ bool IsPlaybackBlocked()
{
MOZ_ASSERT(!mIsShutDown);
// If the tab hasn't been activated yet, the media element in that tab can't
// be playback now until the tab goes to foreground first time or user clicks
// the unblocking tab icon.
if (!IsTabActivated()) {
// Even we haven't start playing yet, we still need to notify the audio
// channe system because we need to receive the resume notification later.
UpdateAudioChannelPlayingState(true /* force to start */);
return true;
}
return false;
}
- void
- Shutdown()
+ void Shutdown()
{
MOZ_ASSERT(!mIsShutDown);
if (mAudioChannelAgent) {
mAudioChannelAgent->NotifyStoppedPlaying();
mAudioChannelAgent = nullptr;
}
mIsShutDown = true;
}
- float
- GetEffectiveVolume() const
+ float GetEffectiveVolume() const
{
MOZ_ASSERT(!mIsShutDown);
return mOwner->Volume() * mAudioChannelVolume;
}
- SuspendTypes
- GetSuspendType() const
+ SuspendTypes GetSuspendType() const
{
MOZ_ASSERT(!mIsShutDown);
return mSuspended;
}
private:
- ~AudioChannelAgentCallback()
- {
- MOZ_ASSERT(mIsShutDown);
- };
-
- bool
- MaybeCreateAudioChannelAgent()
+ ~AudioChannelAgentCallback() { MOZ_ASSERT(mIsShutDown); };
+
+ bool MaybeCreateAudioChannelAgent()
{
if (mAudioChannelAgent) {
return true;
}
mAudioChannelAgent = new AudioChannelAgent();
- nsresult rv = mAudioChannelAgent->Init(mOwner->OwnerDoc()->GetInnerWindow(), this);
+ nsresult rv =
+ mAudioChannelAgent->Init(mOwner->OwnerDoc()->GetInnerWindow(), this);
if (NS_WARN_IF(NS_FAILED(rv))) {
mAudioChannelAgent = nullptr;
- MOZ_LOG(AudioChannelService::GetAudioChannelLog(), LogLevel::Debug,
- ("HTMLMediaElement::AudioChannelAgentCallback, Fail to initialize "
- "the audio channel agent, this = %p\n", this));
+ MOZ_LOG(
+ AudioChannelService::GetAudioChannelLog(),
+ LogLevel::Debug,
+ ("HTMLMediaElement::AudioChannelAgentCallback, Fail to initialize "
+ "the audio channel agent, this = %p\n",
+ this));
return false;
}
return true;
}
- void
- NotifyAudioChannelAgent(bool aPlaying)
+ void NotifyAudioChannelAgent(bool aPlaying)
{
MOZ_ASSERT(mAudioChannelAgent);
if (aPlaying) {
AudioPlaybackConfig config;
- nsresult rv = mAudioChannelAgent->NotifyStartedPlaying(&config,
- IsOwnerAudible());
+ nsresult rv =
+ mAudioChannelAgent->NotifyStartedPlaying(&config, IsOwnerAudible());
if (NS_WARN_IF(NS_FAILED(rv))) {
return;
}
WindowVolumeChanged(config.mVolume, config.mMuted);
WindowSuspendChanged(config.mSuspend);
} else {
mAudioChannelAgent->NotifyStoppedPlaying();
}
}
- void
- SetSuspended(SuspendTypes aSuspend)
+ void SetSuspended(SuspendTypes aSuspend)
{
if (mSuspended == aSuspend) {
return;
}
MaybeNotifyMediaResumed(aSuspend);
mSuspended = aSuspend;
- MOZ_LOG(AudioChannelService::GetAudioChannelLog(), LogLevel::Debug,
- ("HTMLMediaElement::AudioChannelAgentCallback, SetAudioChannelSuspended, "
- "this = %p, aSuspend = %s\n", this, SuspendTypeToStr(aSuspend)));
- }
-
- void
- Resume()
+ MOZ_LOG(
+ AudioChannelService::GetAudioChannelLog(),
+ LogLevel::Debug,
+ ("HTMLMediaElement::AudioChannelAgentCallback, SetAudioChannelSuspended, "
+ "this = %p, aSuspend = %s\n",
+ this,
+ SuspendTypeToStr(aSuspend)));
+ }
+
+ void Resume()
{
if (!IsSuspended()) {
- MOZ_LOG(AudioChannelService::GetAudioChannelLog(), LogLevel::Debug,
- ("HTMLMediaElement::AudioChannelAgentCallback, ResumeFromAudioChannel, "
- "this = %p, don't need to be resumed!\n", this));
+ MOZ_LOG(
+ AudioChannelService::GetAudioChannelLog(),
+ LogLevel::Debug,
+ ("HTMLMediaElement::AudioChannelAgentCallback, ResumeFromAudioChannel, "
+ "this = %p, don't need to be resumed!\n",
+ this));
return;
}
SetSuspended(nsISuspendedTypes::NONE_SUSPENDED);
IgnoredErrorResult rv;
RefPtr<Promise> toBeIgnored = mOwner->Play(rv);
- MOZ_ASSERT_IF(toBeIgnored && toBeIgnored->State() == Promise::PromiseState::Rejected,
+ MOZ_ASSERT_IF(toBeIgnored &&
+ toBeIgnored->State() == Promise::PromiseState::Rejected,
rv.Failed());
if (rv.Failed()) {
NS_WARNING("Not able to resume from AudioChannel.");
}
NotifyAudioPlaybackChanged(
AudioChannelService::AudibleChangedReasons::ePauseStateChanged);
}
- void
- Suspend(SuspendTypes aSuspend)
+ void Suspend(SuspendTypes aSuspend)
{
if (IsSuspended()) {
return;
}
SetSuspended(aSuspend);
if (aSuspend == nsISuspendedTypes::SUSPENDED_PAUSE ||
aSuspend == nsISuspendedTypes::SUSPENDED_PAUSE_DISPOSABLE) {
- nsresult rv = mOwner->Pause();
- if (NS_WARN_IF(NS_FAILED(rv))) {
- return;
- }
+ nsresult rv = mOwner->Pause();
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return;
+ }
}
NotifyAudioPlaybackChanged(
AudioChannelService::AudibleChangedReasons::ePauseStateChanged);
}
- void
- Stop()
+ void Stop()
{
SetSuspended(nsISuspendedTypes::NONE_SUSPENDED);
mOwner->Pause();
}
- bool
- IsPlayingStarted()
+ bool IsPlayingStarted()
{
if (MaybeCreateAudioChannelAgent()) {
return mAudioChannelAgent->IsPlayingStarted();
}
return false;
}
- void
- MaybeNotifyMediaResumed(SuspendTypes aSuspend)
+ void MaybeNotifyMediaResumed(SuspendTypes aSuspend)
{
// In fennec, we should send the notification when media is resumed from the
// pause-disposable which was called by media control.
if (mSuspended != nsISuspendedTypes::SUSPENDED_PAUSE_DISPOSABLE &&
aSuspend != nsISuspendedTypes::NONE_SUSPENDED) {
return;
}
@@ -1023,64 +1032,59 @@ private:
}
wrapper->SetData(windowID);
observerService->NotifyObservers(
wrapper, "media-playback-resumed", u"active");
}));
}
- bool
- IsTabActivated()
+ bool IsTabActivated()
{
if (MaybeCreateAudioChannelAgent()) {
return !mAudioChannelAgent->ShouldBlockMedia();
}
return false;
}
- bool
- IsSuspended() const
+ bool IsSuspended() const
{
return (mSuspended == nsISuspendedTypes::SUSPENDED_PAUSE ||
mSuspended == nsISuspendedTypes::SUSPENDED_PAUSE_DISPOSABLE ||
mSuspended == nsISuspendedTypes::SUSPENDED_BLOCK);
}
- AudibleState
- IsOwnerAudible() const
+ AudibleState IsOwnerAudible() const
{
// Muted or the volume should not be ~0
if (mOwner->mMuted || (std::fabs(mOwner->Volume()) <= 1e-7)) {
- return mOwner->HasAudio() ?
- AudioChannelService::AudibleState::eMaybeAudible :
- AudioChannelService::AudibleState::eNotAudible;
+ return mOwner->HasAudio()
+ ? AudioChannelService::AudibleState::eMaybeAudible
+ : AudioChannelService::AudibleState::eNotAudible;
}
// No audio track.
if (!mOwner->HasAudio()) {
return AudioChannelService::AudibleState::eNotAudible;
}
// Might be audible but not yet.
if (mOwner->HasAudio() && !mOwner->mIsAudioTrackAudible) {
return AudioChannelService::AudibleState::eMaybeAudible;
}
// Suspended or paused media doesn't produce any sound.
- if (mSuspended != nsISuspendedTypes::NONE_SUSPENDED ||
- mOwner->mPaused) {
+ if (mSuspended != nsISuspendedTypes::NONE_SUSPENDED || mOwner->mPaused) {
return AudioChannelService::AudibleState::eNotAudible;
}
return AudioChannelService::AudibleState::eAudible;
}
- bool
- IsPlayingThroughTheAudioChannel() const
+ bool IsPlayingThroughTheAudioChannel() const
{
// If we have an error, we are not playing.
if (mOwner->GetError()) {
return false;
}
// We should consider any bfcached page or inactive document as non-playing.
if (!mOwner->IsActive()) {
@@ -1147,68 +1151,75 @@ private:
SuspendTypes mSuspended;
// Indicate whether media element is audible for users.
AudibleState mIsOwnerAudible;
bool mIsShutDown;
};
NS_IMPL_CYCLE_COLLECTION_CLASS(HTMLMediaElement::AudioChannelAgentCallback)
-NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(HTMLMediaElement::AudioChannelAgentCallback)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(
+ HTMLMediaElement::AudioChannelAgentCallback)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mAudioChannelAgent)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
-NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(HTMLMediaElement::AudioChannelAgentCallback)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(
+ HTMLMediaElement::AudioChannelAgentCallback)
NS_IMPL_CYCLE_COLLECTION_UNLINK(mAudioChannelAgent)
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
-NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(HTMLMediaElement::AudioChannelAgentCallback)
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(
+ HTMLMediaElement::AudioChannelAgentCallback)
NS_INTERFACE_MAP_ENTRY(nsIAudioChannelAgentCallback)
NS_INTERFACE_MAP_END
NS_IMPL_CYCLE_COLLECTING_ADDREF(HTMLMediaElement::AudioChannelAgentCallback)
NS_IMPL_CYCLE_COLLECTING_RELEASE(HTMLMediaElement::AudioChannelAgentCallback)
-class HTMLMediaElement::ChannelLoader final {
+class HTMLMediaElement::ChannelLoader final
+{
public:
NS_INLINE_DECL_REFCOUNTING(ChannelLoader);
void LoadInternal(HTMLMediaElement* aElement)
{
if (mCancelled) {
return;
}
// determine what security checks need to be performed in AsyncOpen2().
- nsSecurityFlags securityFlags = aElement->ShouldCheckAllowOrigin()
- ? nsILoadInfo::SEC_REQUIRE_CORS_DATA_INHERITS :
- nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_DATA_INHERITS;
+ nsSecurityFlags securityFlags =
+ aElement->ShouldCheckAllowOrigin()
+ ? nsILoadInfo::SEC_REQUIRE_CORS_DATA_INHERITS
+ : nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_DATA_INHERITS;
if (aElement->GetCORSMode() == CORS_USE_CREDENTIALS) {
securityFlags |= nsILoadInfo::SEC_COOKIES_INCLUDE;
}
- MOZ_ASSERT(aElement->IsAnyOfHTMLElements(nsGkAtoms::audio, nsGkAtoms::video));
- nsContentPolicyType contentPolicyType = aElement->IsHTMLElement(nsGkAtoms::audio)
- ? nsIContentPolicy::TYPE_INTERNAL_AUDIO :
- nsIContentPolicy::TYPE_INTERNAL_VIDEO;
+ MOZ_ASSERT(
+ aElement->IsAnyOfHTMLElements(nsGkAtoms::audio, nsGkAtoms::video));
+ nsContentPolicyType contentPolicyType =
+ aElement->IsHTMLElement(nsGkAtoms::audio)
+ ? nsIContentPolicy::TYPE_INTERNAL_AUDIO
+ : nsIContentPolicy::TYPE_INTERNAL_VIDEO;
nsCOMPtr<nsILoadGroup> loadGroup = aElement->GetDocumentLoadGroup();
nsCOMPtr<nsIChannel> channel;
- nsresult rv = NS_NewChannel(getter_AddRefs(channel),
- aElement->mLoadingSrc,
- static_cast<Element*>(aElement),
- securityFlags,
- contentPolicyType,
- loadGroup,
- nullptr, // aCallbacks
- nsICachingChannel::LOAD_BYPASS_LOCAL_CACHE_IF_BUSY |
- nsIChannel::LOAD_MEDIA_SNIFFER_OVERRIDES_CONTENT_TYPE |
- nsIChannel::LOAD_CLASSIFY_URI |
- nsIChannel::LOAD_CALL_CONTENT_SNIFFERS);
+ nsresult rv = NS_NewChannel(
+ getter_AddRefs(channel),
+ aElement->mLoadingSrc,
+ static_cast<Element*>(aElement),
+ securityFlags,
+ contentPolicyType,
+ loadGroup,
+ nullptr, // aCallbacks
+ nsICachingChannel::LOAD_BYPASS_LOCAL_CACHE_IF_BUSY |
+ nsIChannel::LOAD_MEDIA_SNIFFER_OVERRIDES_CONTENT_TYPE |
+ nsIChannel::LOAD_CLASSIFY_URI | nsIChannel::LOAD_CALL_CONTENT_SNIFFERS);
if (NS_FAILED(rv)) {
// Notify load error so the element will try next resource candidate.
aElement->NotifyLoadError();
return;
}
nsCOMPtr<nsIClassOfService> cos(do_QueryInterface(channel));
@@ -1236,19 +1247,18 @@ public:
channel->SetNotificationCallbacks(loadListener);
nsCOMPtr<nsIHttpChannel> hc = do_QueryInterface(channel);
if (hc) {
// Use a byte range request from the start of the resource.
// This enables us to detect if the stream supports byte range
// requests, and therefore seeking, early.
- rv = hc->SetRequestHeader(NS_LITERAL_CSTRING("Range"),
- NS_LITERAL_CSTRING("bytes=0-"),
- false);
+ rv = hc->SetRequestHeader(
+ NS_LITERAL_CSTRING("Range"), NS_LITERAL_CSTRING("bytes=0-"), false);
MOZ_ASSERT(NS_SUCCEEDED(rv));
aElement->SetRequestHeaders(hc);
}
rv = channel->AsyncOpen2(loadListener);
if (NS_FAILED(rv)) {
// Notify load error so the element will try next resource candidate.
aElement->NotifyLoadError();
@@ -1267,29 +1277,32 @@ public:
nsresult Load(HTMLMediaElement* aElement)
{
MOZ_ASSERT(aElement);
// Per bug 1235183 comment 8, we can't spin the event loop from stable
// state. Defer NS_NewChannel() to a new regular runnable.
return aElement->MainThreadEventTarget()->Dispatch(
NewRunnableMethod<HTMLMediaElement*>("ChannelLoader::LoadInternal",
- this, &ChannelLoader::LoadInternal, aElement));
+ this,
+ &ChannelLoader::LoadInternal,
+ aElement));
}
void Cancel()
{
mCancelled = true;
if (mChannel) {
mChannel->Cancel(NS_BINDING_ABORTED);
mChannel = nullptr;
}
}
- void Done() {
+ void Done()
+ {
MOZ_ASSERT(mChannel);
// Decoder successfully created, the decoder now owns the MediaResource
// which owns the channel.
mChannel = nullptr;
}
nsresult Redirect(nsIChannel* aChannel,
nsIChannel* aNewChannel,
@@ -1315,20 +1328,17 @@ public:
nsresult rv = http->SetRequestHeader(rangeHdr, rangeVal, false);
NS_ENSURE_SUCCESS(rv, rv);
}
return NS_OK;
}
private:
- ~ChannelLoader()
- {
- MOZ_ASSERT(!mChannel);
- }
+ ~ChannelLoader() { MOZ_ASSERT(!mChannel); }
// Holds a reference to the first channel we open to the media resource.
// Once the decoder is created, control over the channel passes to the
// decoder, and we null out this reference. We must store this in case
// we need to cancel the channel before control of it passes to the decoder.
nsCOMPtr<nsIChannel> mChannel;
bool mCancelled = false;
};
@@ -1388,40 +1398,39 @@ public:
{
mError = nullptr;
mSrcIsUnsupportedTypeMedia = false;
}
void MaybeOpenUnsupportedMediaForOwner() const
{
// Src is supported type or we don't open the pref for external app.
- if (!mSrcIsUnsupportedTypeMedia ||
- !CanOwnerPlayUnsupportedTypeMedia()) {
+ if (!mSrcIsUnsupportedTypeMedia || !CanOwnerPlayUnsupportedTypeMedia()) {
return;
}
// If media doesn't start playing, we don't need to open it.
if (mOwner->Paused()) {
return;
}
- nsContentUtils::DispatchTrustedEvent(mOwner->OwnerDoc(),
- static_cast<nsIContent*>(mOwner),
- NS_LITERAL_STRING("OpenMediaWithExternalApp"),
- true,
- true);
+ nsContentUtils::DispatchTrustedEvent(
+ mOwner->OwnerDoc(),
+ static_cast<nsIContent*>(mOwner),
+ NS_LITERAL_STRING("OpenMediaWithExternalApp"),
+ true,
+ true);
}
RefPtr<MediaError> mError;
private:
bool IsValidErrorCode(const uint16_t& aErrorCode) const
{
- return (aErrorCode == MEDIA_ERR_DECODE ||
- aErrorCode == MEDIA_ERR_NETWORK ||
+ return (aErrorCode == MEDIA_ERR_DECODE || aErrorCode == MEDIA_ERR_NETWORK ||
aErrorCode == MEDIA_ERR_ABORTED ||
aErrorCode == MEDIA_ERR_SRC_NOT_SUPPORTED);
}
bool CanOwnerPlayUnsupportedTypeMedia() const
{
#if defined(MOZ_WIDGET_ANDROID)
// On Fennec, we will use an external app to open unsupported media types.
@@ -1436,17 +1445,18 @@ private:
bool mSrcIsUnsupportedTypeMedia;
};
NS_IMPL_ADDREF_INHERITED(HTMLMediaElement, nsGenericHTMLElement)
NS_IMPL_RELEASE_INHERITED(HTMLMediaElement, nsGenericHTMLElement)
NS_IMPL_CYCLE_COLLECTION_CLASS(HTMLMediaElement)
-NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(HTMLMediaElement, nsGenericHTMLElement)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(HTMLMediaElement,
+ nsGenericHTMLElement)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mMediaSource)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSrcMediaSource)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSrcStream)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSrcAttrStream)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSourcePointer)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mLoadBlockedDoc)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSourceLoadCandidate)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mAudioChannelWrapper)
@@ -1459,17 +1469,18 @@ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mAudioTrackList)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mVideoTrackList)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mMediaKeys)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSelectedVideoStreamTrack)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mPendingPlayPromises)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSeekDOMPromise)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
-NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(HTMLMediaElement, nsGenericHTMLElement)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(HTMLMediaElement,
+ nsGenericHTMLElement)
tmp->RemoveMutationObserver(tmp);
if (tmp->mSrcStream) {
// Need to EndMediaStreamPlayback to clear mSrcStream and make sure everything
// gets unhooked correctly.
tmp->EndSrcMediaStreamPlayback();
}
NS_IMPL_CYCLE_COLLECTION_UNLINK(mSrcAttrStream)
NS_IMPL_CYCLE_COLLECTION_UNLINK(mMediaSource)
@@ -1504,20 +1515,20 @@ NS_IMPL_URI_ATTR(HTMLMediaElement, Src,
NS_IMPL_BOOL_ATTR(HTMLMediaElement, Controls, controls)
NS_IMPL_BOOL_ATTR(HTMLMediaElement, Autoplay, autoplay)
NS_IMPL_BOOL_ATTR(HTMLMediaElement, Loop, loop)
NS_IMPL_BOOL_ATTR(HTMLMediaElement, DefaultMuted, muted)
NS_IMPL_ENUM_ATTR_DEFAULT_VALUE(HTMLMediaElement, Preload, preload, nullptr)
void
HTMLMediaElement::ContentRemoved(nsIDocument* aDocument,
- nsIContent* aContainer,
- nsIContent* aChild,
+ nsIContent* aContainer,
+ nsIContent* aChild,
int32_t /* aIndexInContainer */,
- nsIContent* aPreviousSibling)
+ nsIContent* aPreviousSibling)
{
if (aChild == mSourcePointer) {
mSourcePointer = aPreviousSibling;
}
}
NS_IMETHODIMP_(bool)
HTMLMediaElement::IsVideo()
@@ -1558,23 +1569,22 @@ HTMLMediaElement::MozRequestDebugInfo(Er
GetEMEInfo(EMEInfo);
result.AppendLiteral("EME Info: ");
result.Append(EMEInfo);
result.AppendLiteral("\n");
}
if (mDecoder) {
mDecoder->RequestDebugInfo()->Then(
- mAbstractMainThread, __func__,
- [promise, result] (const nsACString& aString) {
+ mAbstractMainThread,
+ __func__,
+ [promise, result](const nsACString& aString) {
promise->MaybeResolve(result + NS_ConvertUTF8toUTF16(aString));
},
- [promise, result] () {
- promise->MaybeResolve(result);
- });
+ [promise, result]() { promise->MaybeResolve(result); });
} else {
promise->MaybeResolve(result);
}
return promise.forget();
}
void
@@ -1661,72 +1671,78 @@ HTMLMediaElement::SetMozSrcObject(DOMMed
void
HTMLMediaElement::SetMozSrcObject(DOMMediaStream* aValue)
{
mSrcAttrStream = aValue;
UpdateAudioChannelPlayingState();
DoLoad();
}
-NS_IMETHODIMP HTMLMediaElement::GetMozAutoplayEnabled(bool *aAutoplayEnabled)
+NS_IMETHODIMP
+HTMLMediaElement::GetMozAutoplayEnabled(bool* aAutoplayEnabled)
{
*aAutoplayEnabled = mAutoplayEnabled;
return NS_OK;
}
bool
HTMLMediaElement::Ended()
{
return (mDecoder && mDecoder->IsEnded()) ||
(mSrcStream && !mSrcStream->Active());
}
-NS_IMETHODIMP HTMLMediaElement::GetEnded(bool* aEnded)
+NS_IMETHODIMP
+HTMLMediaElement::GetEnded(bool* aEnded)
{
*aEnded = Ended();
return NS_OK;
}
-NS_IMETHODIMP HTMLMediaElement::GetCurrentSrc(nsAString & aCurrentSrc)
+NS_IMETHODIMP
+HTMLMediaElement::GetCurrentSrc(nsAString& aCurrentSrc)
{
nsAutoCString src;
GetCurrentSpec(src);
aCurrentSrc = NS_ConvertUTF8toUTF16(src);
return NS_OK;
}
-NS_IMETHODIMP HTMLMediaElement::GetNetworkState(uint16_t* aNetworkState)
+NS_IMETHODIMP
+HTMLMediaElement::GetNetworkState(uint16_t* aNetworkState)
{
*aNetworkState = NetworkState();
return NS_OK;
}
nsresult
HTMLMediaElement::OnChannelRedirect(nsIChannel* aChannel,
nsIChannel* aNewChannel,
uint32_t aFlags)
{
MOZ_ASSERT(mChannelLoader);
return mChannelLoader->Redirect(aChannel, aNewChannel, aFlags);
}
-void HTMLMediaElement::ShutdownDecoder()
+void
+HTMLMediaElement::ShutdownDecoder()
{
RemoveMediaElementFromURITable();
NS_ASSERTION(mDecoder, "Must have decoder to shut down");
mWaitingForKeyListener.DisconnectIfExists();
if (mMediaSource) {
mMediaSource->CompletePendingTransactions();
}
mDecoder->Shutdown();
mDecoder = nullptr;
}
-void HTMLMediaElement::AbortExistingLoads()
+void
+HTMLMediaElement::AbortExistingLoads()
{
// If there is no existing decoder then we don't have anything to
// report. This prevents reporting the initial load from an
// empty video element as a failed EME load.
if (mDecoder) {
ReportEMETelemetry();
}
// Abort any already-running instance of the resource selection algorithm.
@@ -1773,18 +1789,17 @@ void HTMLMediaElement::AbortExistingLoad
EndSrcMediaStreamPlayback();
}
RemoveMediaElementFromURITable();
mLoadingSrc = nullptr;
mMediaSource = nullptr;
if (mNetworkState == nsIDOMHTMLMediaElement::NETWORK_LOADING ||
- mNetworkState == nsIDOMHTMLMediaElement::NETWORK_IDLE)
- {
+ mNetworkState == nsIDOMHTMLMediaElement::NETWORK_IDLE) {
DispatchAsyncEvent(NS_LITERAL_STRING("abort"));
}
mErrorSink->ResetError();
mCurrentPlayRangeStart = -1.0;
mLoadedDataFired = false;
mAutoplaying = true;
mIsLoadingFromSourceChildren = false;
@@ -1797,17 +1812,18 @@ void HTMLMediaElement::AbortExistingLoad
mIsEncrypted = false;
mPendingEncryptedInitData.Reset();
mWaitingForKey = NOT_WAITING_FOR_KEY;
mSourcePointer = nullptr;
mTags = nullptr;
if (mNetworkState != nsIDOMHTMLMediaElement::NETWORK_EMPTY) {
- NS_ASSERTION(!mDecoder && !mSrcStream, "How did someone setup a new stream/decoder already?");
+ NS_ASSERTION(!mDecoder && !mSrcStream,
+ "How did someone setup a new stream/decoder already?");
// ChangeNetworkState() will call UpdateAudioChannelPlayingState()
// indirectly which depends on mPaused. So we need to update mPaused first.
if (!mPaused) {
mPaused = true;
RejectPromises(TakePendingPlayPromises(), NS_ERROR_DOM_MEDIA_ABORT_ERR);
}
ChangeNetworkState(nsIDOMHTMLMediaElement::NETWORK_EMPTY);
ChangeReadyState(nsIDOMHTMLMediaElement::HAVE_NOTHING);
@@ -1837,120 +1853,133 @@ void HTMLMediaElement::AbortExistingLoad
if (mTextTrackManager) {
mTextTrackManager->NotifyReset();
}
mEventDeliveryPaused = false;
mPendingEvents.Clear();
}
-void HTMLMediaElement::NoSupportedMediaSourceError(const nsACString& aErrorDetails)
+void
+HTMLMediaElement::NoSupportedMediaSourceError(const nsACString& aErrorDetails)
{
if (mDecoder) {
ShutdownDecoder();
}
mErrorSink->SetError(MEDIA_ERR_SRC_NOT_SUPPORTED, aErrorDetails);
ChangeDelayLoadStatus(false);
UpdateAudioChannelPlayingState();
- RejectPromises(TakePendingPlayPromises(), NS_ERROR_DOM_MEDIA_NOT_SUPPORTED_ERR);
+ RejectPromises(TakePendingPlayPromises(),
+ NS_ERROR_DOM_MEDIA_NOT_SUPPORTED_ERR);
}
typedef void (HTMLMediaElement::*SyncSectionFn)();
// Runs a "synchronous section", a function that must run once the event loop
// has reached a "stable state". See:
// http://www.whatwg.org/specs/web-apps/current-work/multipage/webappapis.html#synchronous-section
class nsSyncSection : public nsMediaEvent
{
private:
nsCOMPtr<nsIRunnable> mRunnable;
+
public:
- nsSyncSection(HTMLMediaElement* aElement,
- nsIRunnable* aRunnable) :
- nsMediaEvent("dom::nsSyncSection", aElement),
- mRunnable(aRunnable)
+ nsSyncSection(HTMLMediaElement* aElement, nsIRunnable* aRunnable)
+ : nsMediaEvent("dom::nsSyncSection", aElement)
+ , mRunnable(aRunnable)
+ {}
+
+ NS_IMETHOD Run() override
{
- }
-
- NS_IMETHOD Run() override {
// Silently cancel if our load has been cancelled.
if (IsCancelled())
return NS_OK;
mRunnable->Run();
return NS_OK;
}
};
-void HTMLMediaElement::RunInStableState(nsIRunnable* aRunnable)
+void
+HTMLMediaElement::RunInStableState(nsIRunnable* aRunnable)
{
if (mShuttingDown) {
return;
}
nsCOMPtr<nsIRunnable> event = new nsSyncSection(this, aRunnable);
nsContentUtils::RunInStableState(event.forget());
}
-void HTMLMediaElement::QueueLoadFromSourceTask()
+void
+HTMLMediaElement::QueueLoadFromSourceTask()
{
if (!mIsLoadingFromSourceChildren || mShuttingDown) {
return;
}
ChangeDelayLoadStatus(true);
ChangeNetworkState(nsIDOMHTMLMediaElement::NETWORK_LOADING);
- RefPtr<Runnable> r = NewRunnableMethod("HTMLMediaElement::LoadFromSourceChildren",
- this, &HTMLMediaElement::LoadFromSourceChildren);
+ RefPtr<Runnable> r =
+ NewRunnableMethod("HTMLMediaElement::LoadFromSourceChildren",
+ this,
+ &HTMLMediaElement::LoadFromSourceChildren);
RunInStableState(r);
}
-void HTMLMediaElement::QueueSelectResourceTask()
+void
+HTMLMediaElement::QueueSelectResourceTask()
{
// Don't allow multiple async select resource calls to be queued.
if (mHaveQueuedSelectResource)
return;
mHaveQueuedSelectResource = true;
ChangeNetworkState(nsIDOMHTMLMediaElement::NETWORK_NO_SOURCE);
- RefPtr<Runnable> r = NewRunnableMethod("HTMLMediaElement::SelectResourceWrapper",
- this, &HTMLMediaElement::SelectResourceWrapper);
+ RefPtr<Runnable> r =
+ NewRunnableMethod("HTMLMediaElement::SelectResourceWrapper",
+ this,
+ &HTMLMediaElement::SelectResourceWrapper);
RunInStableState(r);
}
-static bool HasSourceChildren(nsIContent* aElement)
-{
- for (nsIContent* child = aElement->GetFirstChild();
- child;
+static bool
+HasSourceChildren(nsIContent* aElement)
+{
+ for (nsIContent* child = aElement->GetFirstChild(); child;
child = child->GetNextSibling()) {
- if (child->IsHTMLElement(nsGkAtoms::source))
- {
+ if (child->IsHTMLElement(nsGkAtoms::source)) {
return true;
}
}
return false;
}
-NS_IMETHODIMP HTMLMediaElement::Load()
+NS_IMETHODIMP
+HTMLMediaElement::Load()
{
LOG(LogLevel::Debug,
("%p Load() hasSrcAttrStream=%d hasSrcAttr=%d hasSourceChildren=%d "
"handlingInput=%d",
- this, !!mSrcAttrStream, HasAttr(kNameSpaceID_None, nsGkAtoms::src),
- HasSourceChildren(this), EventStateManager::IsHandlingUserInput()));
+ this,
+ !!mSrcAttrStream,
+ HasAttr(kNameSpaceID_None, nsGkAtoms::src),
+ HasSourceChildren(this),
+ EventStateManager::IsHandlingUserInput()));
if (mIsRunningLoadMethod) {
return NS_OK;
}
mIsDoingExplicitLoad = true;
DoLoad();
return NS_OK;
}
-void HTMLMediaElement::DoLoad()
+void
+HTMLMediaElement::DoLoad()
{
if (mIsRunningLoadMethod) {
return;
}
// Detect if user has interacted with element so that play will not be
// blocked when initiated by a script. This enables sites to capture user
// intent to play by calling load() in the click handler of a "catalog
@@ -1969,37 +1998,40 @@ void HTMLMediaElement::DoLoad()
mIsRunningLoadMethod = true;
AbortExistingLoads();
SetPlaybackRate(mDefaultPlaybackRate);
QueueSelectResourceTask();
ResetState();
mIsRunningLoadMethod = false;
}
-void HTMLMediaElement::ResetState()
+void
+HTMLMediaElement::ResetState()
{
// There might be a pending MediaDecoder::PlaybackPositionChanged() which
// will overwrite |mMediaInfo.mVideo.mDisplay| in UpdateMediaSize() to give
// staled videoWidth and videoHeight. We have to call ForgetElement() here
// such that the staled callbacks won't reach us.
if (mVideoFrameContainer) {
mVideoFrameContainer->ForgetElement();
mVideoFrameContainer = nullptr;
}
}
-void HTMLMediaElement::SelectResourceWrapper()
+void
+HTMLMediaElement::SelectResourceWrapper()
{
SelectResource();
mIsRunningSelectResource = false;
mHaveQueuedSelectResource = false;
mIsDoingExplicitLoad = false;
}
-void HTMLMediaElement::SelectResource()
+void
+HTMLMediaElement::SelectResource()
{
if (!mSrcAttrStream && !HasAttr(kNameSpaceID_None, nsGkAtoms::src) &&
!HasSourceChildren(this)) {
// The media element has neither a src attribute nor any source
// element children, abort the load.
ChangeNetworkState(nsIDOMHTMLMediaElement::NETWORK_EMPTY);
ChangeDelayLoadStatus(false);
return;
@@ -2019,18 +2051,21 @@ void HTMLMediaElement::SelectResource()
// If we have a 'src' attribute, use that exclusively.
nsAutoString src;
if (mSrcAttrStream) {
SetupSrcMediaStreamPlayback(mSrcAttrStream);
} else if (GetAttr(kNameSpaceID_None, nsGkAtoms::src, src)) {
nsCOMPtr<nsIURI> uri;
nsresult rv = NewURIFromString(src, getter_AddRefs(uri));
if (NS_SUCCEEDED(rv)) {
- LOG(LogLevel::Debug, ("%p Trying load from src=%s", this, NS_ConvertUTF16toUTF8(src).get()));
- NS_ASSERTION(!mIsLoadingFromSourceChildren,
+ LOG(
+ LogLevel::Debug,
+ ("%p Trying load from src=%s", this, NS_ConvertUTF16toUTF8(src).get()));
+ NS_ASSERTION(
+ !mIsLoadingFromSourceChildren,
"Should think we're not loading from source children by default");
RemoveMediaElementFromURITable();
mLoadingSrc = uri;
mMediaSource = mSrcMediaSource;
UpdatePreloadAction();
if (mPreloadAction == HTMLMediaElement::PRELOAD_NONE &&
!IsMediaStreamURI(mLoadingSrc) && !mMediaSource) {
@@ -2048,17 +2083,19 @@ void HTMLMediaElement::SelectResource()
const char16_t* params[] = { src.get() };
ReportLoadError("MediaLoadInvalidURI", params, ArrayLength(params));
}
// The media element has neither a src attribute nor a source element child:
// set the networkState to NETWORK_EMPTY, and abort these steps; the
// synchronous section ends.
mMainThreadEventTarget->Dispatch(NewRunnableMethod<nsCString>(
"HTMLMediaElement::NoSupportedMediaSourceError",
- this, &HTMLMediaElement::NoSupportedMediaSourceError, nsCString()));
+ this,
+ &HTMLMediaElement::NoSupportedMediaSourceError,
+ nsCString()));
} else {
// Otherwise, the source elements will be used.
mIsLoadingFromSourceChildren = true;
LoadFromSourceChildren();
}
}
void
@@ -2070,29 +2107,32 @@ HTMLMediaElement::NotifyLoadError(const
} else if (mSourceLoadCandidate) {
DispatchAsyncSourceError(mSourceLoadCandidate);
QueueLoadFromSourceTask();
} else {
NS_WARNING("Should know the source we were loading from!");
}
}
-void HTMLMediaElement::NotifyMediaTrackEnabled(MediaTrack* aTrack)
+void
+HTMLMediaElement::NotifyMediaTrackEnabled(MediaTrack* aTrack)
{
MOZ_ASSERT(aTrack);
if (!aTrack) {
return;
}
#ifdef DEBUG
nsString id;
aTrack->GetId(id);
- LOG(LogLevel::Debug, ("MediaElement %p %sTrack with id %s enabled",
- this, aTrack->AsAudioTrack() ? "Audio" : "Video",
- NS_ConvertUTF16toUTF8(id).get()));
+ LOG(LogLevel::Debug,
+ ("MediaElement %p %sTrack with id %s enabled",
+ this,
+ aTrack->AsAudioTrack() ? "Audio" : "Video",
+ NS_ConvertUTF16toUTF8(id).get()));
#endif
MOZ_ASSERT((aTrack->AsAudioTrack() && aTrack->AsAudioTrack()->Enabled()) ||
(aTrack->AsVideoTrack() && aTrack->AsVideoTrack()->Selected()));
if (aTrack->AsAudioTrack()) {
SetMutedInternal(mMuted & ~MUTED_BY_AUDIO_TRACK);
} else if (aTrack->AsVideoTrack()) {
@@ -2134,29 +2174,32 @@ void HTMLMediaElement::NotifyMediaTrackE
// If the output stream is for audio only we ignore video tracks.
continue;
}
AddCaptureMediaTrackToOutputStream(aTrack, ms);
}
}
}
-void HTMLMediaElement::NotifyMediaTrackDisabled(MediaTrack* aTrack)
+void
+HTMLMediaElement::NotifyMediaTrackDisabled(MediaTrack* aTrack)
{
MOZ_ASSERT(aTrack);
if (!aTrack) {
return;
}
#ifdef DEBUG
nsString id;
aTrack->GetId(id);
- LOG(LogLevel::Debug, ("MediaElement %p %sTrack with id %s disabled",
- this, aTrack->AsAudioTrack() ? "Audio" : "Video",
- NS_ConvertUTF16toUTF8(id).get()));
+ LOG(LogLevel::Debug,
+ ("MediaElement %p %sTrack with id %s disabled",
+ this,
+ aTrack->AsAudioTrack() ? "Audio" : "Video",
+ NS_ConvertUTF16toUTF8(id).get()));
#endif
MOZ_ASSERT((!aTrack->AsAudioTrack() || !aTrack->AsAudioTrack()->Enabled()) &&
(!aTrack->AsVideoTrack() || !aTrack->AsVideoTrack()->Selected()));
if (aTrack->AsAudioTrack()) {
// If we don't have any alive track , we don't need to mute MediaElement.
if (AudioTracks()->Length() > 0) {
@@ -2171,17 +2214,18 @@ void HTMLMediaElement::NotifyMediaTrackD
if (shouldMute) {
SetMutedInternal(mMuted | MUTED_BY_AUDIO_TRACK);
}
}
} else if (aTrack->AsVideoTrack()) {
if (mSrcStream) {
MOZ_ASSERT(mSelectedVideoStreamTrack);
if (mSelectedVideoStreamTrack && mMediaStreamSizeListener) {
- mSelectedVideoStreamTrack->RemoveDirectListener(mMediaStreamSizeListener);
+ mSelectedVideoStreamTrack->RemoveDirectListener(
+ mMediaStreamSizeListener);
mMediaStreamSizeListener->Forget();
mMediaStreamSizeListener = nullptr;
}
VideoFrameContainer* container = GetVideoFrameContainer();
if (mSrcStreamIsPlaying && container) {
mSelectedVideoStreamTrack->RemoveVideoOutput(container);
}
mSelectedVideoStreamTrack = nullptr;
@@ -2202,40 +2246,43 @@ void HTMLMediaElement::NotifyMediaTrackD
MOZ_ASSERT(ms.mCapturingMediaStream);
for (int32_t i = ms.mTrackPorts.Length() - 1; i >= 0; --i) {
if (ms.mTrackPorts[i].first() == aTrack->GetId()) {
// The source of this track just ended. Force-notify that it ended.
// If we bounce it to the MediaStreamGraph it might not be picked up,
// for instance if the MediaInputPort was destroyed in the same
// iteration as it was added.
MediaStreamTrack* outputTrack = ms.mStream->FindOwnedDOMTrack(
- ms.mTrackPorts[i].second()->GetDestination(),
- ms.mTrackPorts[i].second()->GetDestinationTrackId());
+ ms.mTrackPorts[i].second()->GetDestination(),
+ ms.mTrackPorts[i].second()->GetDestinationTrackId());
MOZ_ASSERT(outputTrack);
if (outputTrack) {
- mMainThreadEventTarget->Dispatch(NewRunnableMethod(
- "MediaStreamTrack::OverrideEnded",
- outputTrack, &MediaStreamTrack::OverrideEnded));
+ mMainThreadEventTarget->Dispatch(
+ NewRunnableMethod("MediaStreamTrack::OverrideEnded",
+ outputTrack,
+ &MediaStreamTrack::OverrideEnded));
}
ms.mTrackPorts[i].second()->Destroy();
ms.mTrackPorts.RemoveElementAt(i);
break;
}
}
#ifdef DEBUG
for (auto pair : ms.mTrackPorts) {
MOZ_ASSERT(pair.first() != aTrack->GetId(),
- "The same MediaTrack was forwarded to the output stream more than once. This shouldn't happen.");
+ "The same MediaTrack was forwarded to the output stream more "
+ "than once. This shouldn't happen.");
}
#endif
}
}
-void HTMLMediaElement::NotifyMediaStreamTracksAvailable(DOMMediaStream* aStream)
+void
+HTMLMediaElement::NotifyMediaStreamTracksAvailable(DOMMediaStream* aStream)
{
if (!mSrcStream || mSrcStream != aStream) {
return;
}
LOG(LogLevel::Debug, ("MediaElement %p MediaStream tracks available", this));
mSrcStreamTracksAvailable = true;
@@ -2246,26 +2293,28 @@ void HTMLMediaElement::NotifyMediaStream
// We are a video element and HasVideo() changed so update the screen
// wakelock
NotifyOwnerDocumentActivityChanged();
}
mWatchManager.ManualNotify(&HTMLMediaElement::UpdateReadyStateInternal);
}
-void HTMLMediaElement::DealWithFailedElement(nsIContent* aSourceElement)
+void
+HTMLMediaElement::DealWithFailedElement(nsIContent* aSourceElement)
{
if (mShuttingDown) {
return;
}
DispatchAsyncSourceError(aSourceElement);
- mMainThreadEventTarget->Dispatch(NewRunnableMethod(
- "HTMLMediaElement::QueueLoadFromSourceTask",
- this, &HTMLMediaElement::QueueLoadFromSourceTask));
+ mMainThreadEventTarget->Dispatch(
+ NewRunnableMethod("HTMLMediaElement::QueueLoadFromSourceTask",
+ this,
+ &HTMLMediaElement::QueueLoadFromSourceTask));
}
void
HTMLMediaElement::NotifyOutputTrackStopped(DOMMediaStream* aOwningStream,
TrackID aDestinationTrackID)
{
for (OutputMediaStream& ms : mOutputStreams) {
if (!ms.mCapturingMediaStream) {
@@ -2287,17 +2336,18 @@ HTMLMediaElement::NotifyOutputTrackStopp
return;
}
}
// An output track ended but its port is already gone.
// It was probably cleared by the removal of the source MediaTrack.
}
-void HTMLMediaElement::LoadFromSourceChildren()
+void
+HTMLMediaElement::LoadFromSourceChildren()
{
NS_ASSERTION(mDelayingLoadEvent,
"Should delay load event (if in document) during load");
NS_ASSERTION(mIsLoadingFromSourceChildren,
"Must remember we're loading from source children");
AddMutationObserverUnlessExists(this);
@@ -2325,24 +2375,28 @@ void HTMLMediaElement::LoadFromSourceChi
nsAutoString type;
if (child->GetAttr(kNameSpaceID_None, nsGkAtoms::type, type)) {
DecoderDoctorDiagnostics diagnostics;
CanPlayStatus canPlay = GetCanPlay(type, &diagnostics);
diagnostics.StoreFormatDiagnostics(
OwnerDoc(), type, canPlay != CANPLAY_NO, __func__);
if (canPlay == CANPLAY_NO) {
const char16_t* params[] = { type.get(), src.get() };
- ReportLoadError("MediaLoadUnsupportedTypeAttribute", params, ArrayLength(params));
+ ReportLoadError(
+ "MediaLoadUnsupportedTypeAttribute", params, ArrayLength(params));
DealWithFailedElement(child);
return;
}
}
- HTMLSourceElement *childSrc = HTMLSourceElement::FromContent(child);
- LOG(LogLevel::Debug, ("%p Trying load from <source>=%s type=%s", this,
- NS_ConvertUTF16toUTF8(src).get(), NS_ConvertUTF16toUTF8(type).get()));
+ HTMLSourceElement* childSrc = HTMLSourceElement::FromContent(child);
+ LOG(LogLevel::Debug,
+ ("%p Trying load from <source>=%s type=%s",
+ this,
+ NS_ConvertUTF16toUTF8(src).get(),
+ NS_ConvertUTF16toUTF8(type).get()));
nsCOMPtr<nsIURI> uri;
NewURIFromString(src, getter_AddRefs(uri));
if (!uri) {
const char16_t* params[] = { src.get() };
ReportLoadError("MediaLoadInvalidURI", params, ArrayLength(params));
DealWithFailedElement(child);
return;
@@ -2367,27 +2421,30 @@ void HTMLMediaElement::LoadFromSourceChi
}
// If we fail to load, loop back and try loading the next resource.
DispatchAsyncSourceError(child);
}
NS_NOTREACHED("Execution should not reach here!");
}
-void HTMLMediaElement::SuspendLoad()
+void
+HTMLMediaElement::SuspendLoad()
{
mSuspendedForPreloadNone = true;
ChangeNetworkState(nsIDOMHTMLMediaElement::NETWORK_IDLE);
ChangeDelayLoadStatus(false);
}
-void HTMLMediaElement::ResumeLoad(PreloadAction aAction)
+void
+HTMLMediaElement::ResumeLoad(PreloadAction aAction)
{
NS_ASSERTION(mSuspendedForPreloadNone,
- "Must be halted for preload:none to resume from preload:none suspended load.");
+ "Must be halted for preload:none to resume from preload:none "
+ "suspended load.");
mSuspendedForPreloadNone = false;
mPreloadAction = aAction;
ChangeDelayLoadStatus(true);
ChangeNetworkState(nsIDOMHTMLMediaElement::NETWORK_LOADING);
if (!mIsLoadingFromSourceChildren) {
// We were loading from the element's src attribute.
if (NS_FAILED(LoadResource())) {
NoSupportedMediaSourceError();
@@ -2396,47 +2453,48 @@ void HTMLMediaElement::ResumeLoad(Preloa
// We were loading from a child <source> element. Try to resume the
// load of that child, and if that fails, try the next child.
if (NS_FAILED(LoadResource())) {
LoadFromSourceChildren();
}
}
}
-void HTMLMediaElement::UpdatePreloadAction()
+void
+HTMLMediaElement::UpdatePreloadAction()
{
PreloadAction nextAction = PRELOAD_UNDEFINED;
// If autoplay is set, or we're playing, we should always preload data,
// as we'll need it to play.
- if ((IsAutoplayEnabled() && HasAttr(kNameSpaceID_None, nsGkAtoms::autoplay)) ||
- !mPaused)
- {
+ if ((IsAutoplayEnabled() &&
+ HasAttr(kNameSpaceID_None, nsGkAtoms::autoplay)) ||
+ !mPaused) {
nextAction = HTMLMediaElement::PRELOAD_ENOUGH;
} else {
// Find the appropriate preload action by looking at the attribute.
- const nsAttrValue* val = mAttrsAndChildren.GetAttr(nsGkAtoms::preload,
- kNameSpaceID_None);
+ const nsAttrValue* val =
+ mAttrsAndChildren.GetAttr(nsGkAtoms::preload, kNameSpaceID_None);
// MSE doesn't work if preload is none, so it ignores the pref when src is
// from MSE.
- uint32_t preloadDefault = mMediaSource ?
- HTMLMediaElement::PRELOAD_ATTR_METADATA :
- Preferences::GetInt("media.preload.default",
- HTMLMediaElement::PRELOAD_ATTR_METADATA);
- uint32_t preloadAuto =
- Preferences::GetInt("media.preload.auto",
- HTMLMediaElement::PRELOAD_ENOUGH);
+ uint32_t preloadDefault =
+ mMediaSource
+ ? HTMLMediaElement::PRELOAD_ATTR_METADATA
+ : Preferences::GetInt("media.preload.default",
+ HTMLMediaElement::PRELOAD_ATTR_METADATA);
+ uint32_t preloadAuto = Preferences::GetInt(
+ "media.preload.auto", HTMLMediaElement::PRELOAD_ENOUGH);
if (!val) {
// Attribute is not set. Use the preload action specified by the
// media.preload.default pref, or just preload metadata if not present.
nextAction = static_cast<PreloadAction>(preloadDefault);
} else if (val->Type() == nsAttrValue::eEnum) {
- PreloadAttrValue attr = static_cast<PreloadAttrValue>(val->GetEnumValue());
+ PreloadAttrValue attr =
+ static_cast<PreloadAttrValue>(val->GetEnumValue());
if (attr == HTMLMediaElement::PRELOAD_ATTR_EMPTY ||
- attr == HTMLMediaElement::PRELOAD_ATTR_AUTO)
- {
+ attr == HTMLMediaElement::PRELOAD_ATTR_AUTO) {
nextAction = static_cast<PreloadAction>(preloadAuto);
} else if (attr == HTMLMediaElement::PRELOAD_ATTR_METADATA) {
nextAction = HTMLMediaElement::PRELOAD_METADATA;
} else if (attr == HTMLMediaElement::PRELOAD_ATTR_NONE) {
nextAction = HTMLMediaElement::PRELOAD_NONE;
}
} else {
// Use the suggested "missing value default" of "metadata", or the value
@@ -2471,17 +2529,18 @@ void HTMLMediaElement::UpdatePreloadActi
// value "none". The preload value has changed to preload:metadata, so
// resume the load. We'll pause the load again after we've read the
// metadata.
ResumeLoad(PRELOAD_METADATA);
}
}
}
-nsresult HTMLMediaElement::LoadResource()
+nsresult
+HTMLMediaElement::LoadResource()
{
AbstractThread::AutoEnter context(AbstractMainThread());
NS_ASSERTION(mDelayingLoadEvent,
"Should delay load event (if in document) during load");
if (mChannelLoader) {
mChannelLoader->Cancel();
@@ -2504,17 +2563,18 @@ nsresult HTMLMediaElement::LoadResource(
nsresult rv = InitializeDecoderAsClone(
static_cast<ChannelMediaDecoder*>(other->mDecoder.get()));
if (NS_SUCCEEDED(rv))
return rv;
}
if (IsMediaStreamURI(mLoadingSrc)) {
RefPtr<DOMMediaStream> stream;
- nsresult rv = NS_GetStreamForMediaStreamURI(mLoadingSrc, getter_AddRefs(stream));
+ nsresult rv =
+ NS_GetStreamForMediaStreamURI(mLoadingSrc, getter_AddRefs(stream));
if (NS_FAILED(rv)) {
nsAutoString spec;
GetCurrentSrc(spec);
const char16_t* params[] = { spec.get() };
ReportLoadError("MediaLoadInvalidURI", params, ArrayLength(params));
return rv;
}
SetupSrcMediaStreamPlayback(stream);
@@ -2554,18 +2614,19 @@ nsresult HTMLMediaElement::LoadResource(
RefPtr<ChannelLoader> loader = new ChannelLoader;
nsresult rv = loader->Load(this);
if (NS_SUCCEEDED(rv)) {
mChannelLoader = loader.forget();
}
return rv;
}
-nsresult HTMLMediaElement::LoadWithChannel(nsIChannel* aChannel,
- nsIStreamListener** aListener)
+nsresult
+HTMLMediaElement::LoadWithChannel(nsIChannel* aChannel,
+ nsIStreamListener** aListener)
{
NS_ENSURE_ARG_POINTER(aChannel);
NS_ENSURE_ARG_POINTER(aListener);
*aListener = nullptr;
// Make sure we don't reenter during synchronous abort events.
if (mIsRunningLoadMethod)
@@ -2585,30 +2646,32 @@ nsresult HTMLMediaElement::LoadWithChann
}
SetPlaybackRate(mDefaultPlaybackRate);
DispatchAsyncEvent(NS_LITERAL_STRING("loadstart"));
return NS_OK;
}
-NS_IMETHODIMP HTMLMediaElement::GetReadyState(uint16_t* aReadyState)
+NS_IMETHODIMP
+HTMLMediaElement::GetReadyState(uint16_t* aReadyState)
{
*aReadyState = ReadyState();
return NS_OK;
}
bool
HTMLMediaElement::Seeking() const
{
return mDecoder && mDecoder->IsSeeking();
}
-NS_IMETHODIMP HTMLMediaElement::GetSeeking(bool* aSeeking)
+NS_IMETHODIMP
+HTMLMediaElement::GetSeeking(bool* aSeeking)
{
*aSeeking = Seeking();
return NS_OK;
}
double
HTMLMediaElement::CurrentTime() const
{
@@ -2621,17 +2684,18 @@ HTMLMediaElement::CurrentTime() const
if (mDefaultPlaybackStartPosition == 0.0 && mDecoder) {
return mDecoder->GetCurrentTime();
}
return mDefaultPlaybackStartPosition;
}
-NS_IMETHODIMP HTMLMediaElement::GetCurrentTime(double* aCurrentTime)
+NS_IMETHODIMP
+HTMLMediaElement::GetCurrentTime(double* aCurrentTime)
{
*aCurrentTime = CurrentTime();
return NS_OK;
}
void
HTMLMediaElement::FastSeek(double aTime, ErrorResult& aRv)
{
@@ -2715,17 +2779,21 @@ HTMLMediaElement::Seek(double aTime,
if (mSrcStream) {
// do nothing since media streams have an empty Seekable range.
promise->MaybeReject(NS_ERROR_DOM_INVALID_STATE_ERR);
return promise.forget();
}
if (mPlayed && mCurrentPlayRangeStart != -1.0) {
double rangeEndTime = CurrentTime();
- LOG(LogLevel::Debug, ("%p Adding \'played\' a range : [%f, %f]", this, mCurrentPlayRangeStart, rangeEndTime));
+ LOG(LogLevel::Debug,
+ ("%p Adding \'played\' a range : [%f, %f]",
+ this,
+ mCurrentPlayRangeStart,
+ rangeEndTime));
// Multiple seek without playing, or seek while playing.
if (mCurrentPlayRangeStart != rangeEndTime) {
mPlayed->Add(mCurrentPlayRangeStart, rangeEndTime);
}
// Reset the current played range start time. We'll re-set it once
// the seek completes.
mCurrentPlayRangeStart = -1.0;
}
@@ -2828,21 +2896,23 @@ HTMLMediaElement::Seek(double aTime,
AddRemoveSelfReference();
// Keep the DOM promise.
mSeekDOMPromise = promise;
return promise.forget();
}
-NS_IMETHODIMP HTMLMediaElement::SetCurrentTime(double aCurrentTime)
+NS_IMETHODIMP
+HTMLMediaElement::SetCurrentTime(double aCurrentTime)
{
// Detect for a NaN and invalid values.
if (mozilla::IsNaN(aCurrentTime)) {
- LOG(LogLevel::Debug, ("%p SetCurrentTime(%f) failed: bad time", this, aCurrentTime));
+ LOG(LogLevel::Debug,
+ ("%p SetCurrentTime(%f) failed: bad time", this, aCurrentTime));
return NS_ERROR_FAILURE;
}
ErrorResult rv;
SetCurrentTime(aCurrentTime, rv);
return rv.StealNSResult();
}
@@ -2855,39 +2925,42 @@ HTMLMediaElement::Duration() const
if (mDecoder) {
return mDecoder->GetDuration();
}
return std::numeric_limits<double>::quiet_NaN();
}
-NS_IMETHODIMP HTMLMediaElement::GetDuration(double* aDuration)
+NS_IMETHODIMP
+HTMLMediaElement::GetDuration(double* aDuration)
{
*aDuration = Duration();
return NS_OK;
}
already_AddRefed<TimeRanges>
HTMLMediaElement::Seekable() const
{
media::TimeIntervals seekable =
mDecoder ? mDecoder->GetSeekable() : media::TimeIntervals();
RefPtr<TimeRanges> ranges = new TimeRanges(ToSupports(OwnerDoc()), seekable);
return ranges.forget();
}
-NS_IMETHODIMP HTMLMediaElement::GetSeekable(nsIDOMTimeRanges** aSeekable)
+NS_IMETHODIMP
+HTMLMediaElement::GetSeekable(nsIDOMTimeRanges** aSeekable)
{
RefPtr<TimeRanges> ranges = Seekable();
ranges.forget(aSeekable);
return NS_OK;
}
-NS_IMETHODIMP HTMLMediaElement::GetPaused(bool* aPaused)
+NS_IMETHODIMP
+HTMLMediaElement::GetPaused(bool* aPaused)
{
*aPaused = Paused();
return NS_OK;
}
already_AddRefed<TimeRanges>
HTMLMediaElement::Played()
@@ -2912,17 +2985,18 @@ HTMLMediaElement::Played()
ranges->Add(mCurrentPlayRangeStart, now);
}
}
ranges->Normalize();
return ranges.forget();
}
-NS_IMETHODIMP HTMLMediaElement::GetPlayed(nsIDOMTimeRanges** aPlayed)
+NS_IMETHODIMP
+HTMLMediaElement::GetPlayed(nsIDOMTimeRanges** aPlayed)
{
RefPtr<TimeRanges> ranges = Played();
ranges.forget(aPlayed);
return NS_OK;
}
void
HTMLMediaElement::Pause(ErrorResult& aRv)
@@ -2946,24 +3020,26 @@ HTMLMediaElement::Pause(ErrorResult& aRv
if (!oldPaused) {
FireTimeUpdate(false);
DispatchAsyncEvent(NS_LITERAL_STRING("pause"));
AsyncRejectPendingPlayPromises(NS_ERROR_DOM_MEDIA_ABORT_ERR);
}
}
-NS_IMETHODIMP HTMLMediaElement::Pause()
+NS_IMETHODIMP
+HTMLMediaElement::Pause()
{
ErrorResult rv;
Pause(rv);
return rv.StealNSResult();
}
-NS_IMETHODIMP HTMLMediaElement::GetVolume(double* aVolume)
+NS_IMETHODIMP
+HTMLMediaElement::GetVolume(double* aVolume)
{
*aVolume = Volume();
return NS_OK;
}
void
HTMLMediaElement::SetVolume(double aVolume, ErrorResult& aRv)
{
@@ -2978,17 +3054,18 @@ HTMLMediaElement::SetVolume(double aVolu
mVolume = aVolume;
// Here we want just to update the volume.
SetVolumeInternal();
DispatchAsyncEvent(NS_LITERAL_STRING("volumechange"));
}
-NS_IMETHODIMP HTMLMediaElement::SetVolume(double aVolume)
+NS_IMETHODIMP
+HTMLMediaElement::SetVolume(double aVolume)
{
ErrorResult rv;
SetVolume(aVolume, rv);
return rv.StealNSResult();
}
void
HTMLMediaElement::MozGetMetadata(JSContext* cx,
@@ -3005,107 +3082,111 @@ HTMLMediaElement::MozGetMetadata(JSConte
aRv.Throw(NS_ERROR_FAILURE);
return;
}
if (mTags) {
for (auto iter = mTags->ConstIter(); !iter.Done(); iter.Next()) {
nsString wideValue = NS_ConvertUTF8toUTF16(iter.UserData());
JS::Rooted<JSString*> string(cx,
JS_NewUCStringCopyZ(cx, wideValue.Data()));
- if (!string || !JS_DefineProperty(cx, tags, iter.Key().Data(), string,
- JSPROP_ENUMERATE)) {
+ if (!string || !JS_DefineProperty(
+ cx, tags, iter.Key().Data(), string, JSPROP_ENUMERATE)) {
NS_WARNING("couldn't create metadata object!");
aRv.Throw(NS_ERROR_FAILURE);
return;
}
}
}
aRetval.set(tags);
}
NS_IMETHODIMP
-HTMLMediaElement::MozGetMetadata(JSContext* cx, JS::MutableHandle<JS::Value> aValue)
+HTMLMediaElement::MozGetMetadata(JSContext* cx,
+ JS::MutableHandle<JS::Value> aValue)
{
ErrorResult rv;
JS::Rooted<JSObject*> obj(cx);
MozGetMetadata(cx, &obj, rv);
if (!rv.Failed()) {
MOZ_ASSERT(obj);
aValue.setObject(*obj);
}
return rv.StealNSResult();
}
-NS_IMETHODIMP HTMLMediaElement::GetMuted(bool* aMuted)
+NS_IMETHODIMP
+HTMLMediaElement::GetMuted(bool* aMuted)
{
*aMuted = Muted();
return NS_OK;
}
-void HTMLMediaElement::SetMutedInternal(uint32_t aMuted)
+void
+HTMLMediaElement::SetMutedInternal(uint32_t aMuted)
{
uint32_t oldMuted = mMuted;
mMuted = aMuted;
if (!!aMuted == !!oldMuted) {
return;
}
SetVolumeInternal();
}
-void HTMLMediaElement::SetVolumeInternal()
+void
+HTMLMediaElement::SetVolumeInternal()
{
float effectiveVolume = ComputedVolume();
if (mDecoder) {
mDecoder->SetVolume(effectiveVolume);
} else if (MediaStream* stream = GetSrcMediaStream()) {
if (mSrcStreamIsPlaying) {
stream->SetAudioOutputVolume(this, effectiveVolume);
}
}
NotifyAudioPlaybackChanged(
AudioChannelService::AudibleChangedReasons::eVolumeChanged);
}
-NS_IMETHODIMP HTMLMediaElement::SetMuted(bool aMuted)
+NS_IMETHODIMP
+HTMLMediaElement::SetMuted(bool aMuted)
{
if (aMuted == Muted()) {
return NS_OK;
}
if (aMuted) {
SetMutedInternal(mMuted | MUTED_BY_CONTENT);
} else {
SetMutedInternal(mMuted & ~MUTED_BY_CONTENT);
}
DispatchAsyncEvent(NS_LITERAL_STRING("volumechange"));
return NS_OK;
}
-class HTMLMediaElement::StreamCaptureTrackSource :
- public MediaStreamTrackSource,
- public MediaStreamTrackSource::Sink
+class HTMLMediaElement::StreamCaptureTrackSource
+ : public MediaStreamTrackSource
+ , public MediaStreamTrackSource::Sink
{
public:
NS_DECL_ISUPPORTS_INHERITED
NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(StreamCaptureTrackSource,
MediaStreamTrackSource)
StreamCaptureTrackSource(HTMLMediaElement* aElement,
MediaStreamTrackSource* aCapturedTrackSource,
DOMMediaStream* aOwningStream,
TrackID aDestinationTrackID)
- : MediaStreamTrackSource(aCapturedTrackSource->GetPrincipal(),
- nsString())
+ : MediaStreamTrackSource(aCapturedTrackSource->GetPrincipal(), nsString())
, mElement(aElement)
, mCapturedTrackSource(aCapturedTrackSource)
, mOwningStream(aOwningStream)
, mDestinationTrackID(aDestinationTrackID)
{
MOZ_ASSERT(mElement);
MOZ_ASSERT(mCapturedTrackSource);
MOZ_ASSERT(mOwningStream);
@@ -3167,48 +3248,52 @@ private:
RefPtr<DOMMediaStream> mOwningStream;
TrackID mDestinationTrackID;
};
NS_IMPL_ADDREF_INHERITED(HTMLMediaElement::StreamCaptureTrackSource,
MediaStreamTrackSource)
NS_IMPL_RELEASE_INHERITED(HTMLMediaElement::StreamCaptureTrackSource,
MediaStreamTrackSource)
-NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(HTMLMediaElement::StreamCaptureTrackSource)
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(
+ HTMLMediaElement::StreamCaptureTrackSource)
NS_INTERFACE_MAP_END_INHERITING(MediaStreamTrackSource)
NS_IMPL_CYCLE_COLLECTION_INHERITED(HTMLMediaElement::StreamCaptureTrackSource,
MediaStreamTrackSource,
mElement,
mCapturedTrackSource,
mOwningStream)
-class HTMLMediaElement::DecoderCaptureTrackSource :
- public MediaStreamTrackSource,
- public DecoderPrincipalChangeObserver
+class HTMLMediaElement::DecoderCaptureTrackSource
+ : public MediaStreamTrackSource
+ , public DecoderPrincipalChangeObserver
{
public:
NS_DECL_ISUPPORTS_INHERITED
NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(DecoderCaptureTrackSource,
MediaStreamTrackSource)
explicit DecoderCaptureTrackSource(HTMLMediaElement* aElement)
- : MediaStreamTrackSource(nsCOMPtr<nsIPrincipal>(aElement->GetCurrentPrincipal()).get(),
- nsString())
+ : MediaStreamTrackSource(
+ nsCOMPtr<nsIPrincipal>(aElement->GetCurrentPrincipal()).get(),
+ nsString())
, mElement(aElement)
{
MOZ_ASSERT(mElement);
mElement->AddDecoderPrincipalChangeObserver(this);
}
void Destroy() override
{
if (mElement) {
- DebugOnly<bool> res = mElement->RemoveDecoderPrincipalChangeObserver(this);
- NS_ASSERTION(res, "Removing decoder principal changed observer failed. "
- "Had it already been removed?");
+ DebugOnly<bool> res =
+ mElement->RemoveDecoderPrincipalChangeObserver(this);
+ NS_ASSERTION(res,
+ "Removing decoder principal changed observer failed. "
+ "Had it already been removed?");
mElement = nullptr;
}
}
MediaSourceEnum GetMediaSource() const override
{
return MediaSourceEnum::Other;
}
@@ -3235,49 +3320,50 @@ public:
{
nsCOMPtr<nsIPrincipal> newPrincipal = mElement->GetCurrentPrincipal();
if (nsContentUtils::CombineResourcePrincipals(&mPrincipal, newPrincipal)) {
PrincipalChanged();
}
}
protected:
- virtual ~DecoderCaptureTrackSource()
- {
- }
+ virtual ~DecoderCaptureTrackSource() {}
RefPtr<HTMLMediaElement> mElement;
};
NS_IMPL_ADDREF_INHERITED(HTMLMediaElement::DecoderCaptureTrackSource,
MediaStreamTrackSource)
NS_IMPL_RELEASE_INHERITED(HTMLMediaElement::DecoderCaptureTrackSource,
MediaStreamTrackSource)
-NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(HTMLMediaElement::DecoderCaptureTrackSource)
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(
+ HTMLMediaElement::DecoderCaptureTrackSource)
NS_INTERFACE_MAP_END_INHERITING(MediaStreamTrackSource)
NS_IMPL_CYCLE_COLLECTION_INHERITED(HTMLMediaElement::DecoderCaptureTrackSource,
MediaStreamTrackSource,
mElement)
-class HTMLMediaElement::CaptureStreamTrackSourceGetter :
- public MediaStreamTrackSourceGetter
+class HTMLMediaElement::CaptureStreamTrackSourceGetter
+ : public MediaStreamTrackSourceGetter
{
public:
NS_DECL_ISUPPORTS_INHERITED
NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(CaptureStreamTrackSourceGetter,
MediaStreamTrackSourceGetter)
explicit CaptureStreamTrackSourceGetter(HTMLMediaElement* aElement)
- : mElement(aElement) {}
-
- already_AddRefed<dom::MediaStreamTrackSource>
- GetMediaStreamTrackSource(TrackID aInputTrackID) override
+ : mElement(aElement)
+ {}
+
+ already_AddRefed<dom::MediaStreamTrackSource> GetMediaStreamTrackSource(
+ TrackID aInputTrackID) override
{
if (mElement && mElement->mSrcStream) {
- NS_ERROR("Captured media element playing a stream adds tracks explicitly on main thread.");
+ NS_ERROR("Captured media element playing a stream adds tracks explicitly "
+ "on main thread.");
return nullptr;
}
// We can return a new source each time here, even for different streams,
// since the sources don't keep any internal state and all of them call
// through to the same HTMLMediaElement.
// If this changes (after implementing Stop()?) we'll have to ensure we
// return the same source for all requests to the same TrackID, and only
@@ -3290,51 +3376,59 @@ protected:
RefPtr<HTMLMediaElement> mElement;
};
NS_IMPL_ADDREF_INHERITED(HTMLMediaElement::CaptureStreamTrackSourceGetter,
MediaStreamTrackSourceGetter)
NS_IMPL_RELEASE_INHERITED(HTMLMediaElement::CaptureStreamTrackSourceGetter,
MediaStreamTrackSourceGetter)
-NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(HTMLMediaElement::CaptureStreamTrackSourceGetter)
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(
+ HTMLMediaElement::CaptureStreamTrackSourceGetter)
NS_INTERFACE_MAP_END_INHERITING(MediaStreamTrackSourceGetter)
-NS_IMPL_CYCLE_COLLECTION_INHERITED(HTMLMediaElement::CaptureStreamTrackSourceGetter,
- MediaStreamTrackSourceGetter,
- mElement)
-
-void
-HTMLMediaElement::SetCapturedOutputStreamsEnabled(bool aEnabled) {
+NS_IMPL_CYCLE_COLLECTION_INHERITED(
+ HTMLMediaElement::CaptureStreamTrackSourceGetter,
+ MediaStreamTrackSourceGetter,
+ mElement)
+
+void
+HTMLMediaElement::SetCapturedOutputStreamsEnabled(bool aEnabled)
+{
for (OutputMediaStream& ms : mOutputStreams) {
if (ms.mCapturingDecoder) {
MOZ_ASSERT(!ms.mCapturingMediaStream);
continue;
}
for (auto pair : ms.mTrackPorts) {
MediaStream* outputSource = ms.mStream->GetInputStream();
if (!outputSource) {
NS_ERROR("No output source stream");
return;
}
TrackID id = pair.second()->GetDestinationTrackId();
- outputSource->SetTrackEnabled(id, aEnabled ? DisabledTrackMode::ENABLED
- : DisabledTrackMode::SILENCE_FREEZE);
+ outputSource->SetTrackEnabled(id,
+ aEnabled
+ ? DisabledTrackMode::ENABLED
+ : DisabledTrackMode::SILENCE_FREEZE);
LOG(LogLevel::Debug,
("%s track %d for captured MediaStream %p",
- aEnabled ? "Enabled" : "Disabled", id, ms.mStream.get()));
- }
- }
-}
-
-void
-HTMLMediaElement::AddCaptureMediaTrackToOutputStream(MediaTrack* aTrack,
- OutputMediaStream& aOutputStream,
- bool aAsyncAddtrack)
+ aEnabled ? "Enabled" : "Disabled",
+ id,
+ ms.mStream.get()));
+ }
+ }
+}
+
+void
+HTMLMediaElement::AddCaptureMediaTrackToOutputStream(
+ MediaTrack* aTrack,
+ OutputMediaStream& aOutputStream,
+ bool aAsyncAddtrack)
{
if (aOutputStream.mCapturingDecoder) {
MOZ_ASSERT(!aOutputStream.mCapturingMediaStream);
return;
}
aOutputStream.mCapturingMediaStream = true;
if (aOutputStream.mStream == mSrcStream) {
@@ -3371,58 +3465,59 @@ HTMLMediaElement::AddCaptureMediaTrackTo
#if DEBUG
for (auto pair : aOutputStream.mTrackPorts) {
MOZ_ASSERT(pair.first() != aTrack->GetId(),
"Captured track already captured to output stream");
}
#endif
TrackID destinationTrackID = aOutputStream.mNextAvailableTrackID++;
- RefPtr<MediaStreamTrackSource> source =
- new StreamCaptureTrackSource(this,
- &inputTrack->GetSource(),
- aOutputStream.mStream,
- destinationTrackID);
+ RefPtr<MediaStreamTrackSource> source = new StreamCaptureTrackSource(
+ this, &inputTrack->GetSource(), aOutputStream.mStream, destinationTrackID);
MediaSegment::Type type = inputTrack->AsAudioStreamTrack()
- ? MediaSegment::AUDIO
- : MediaSegment::VIDEO;
+ ? MediaSegment::AUDIO
+ : MediaSegment::VIDEO;
RefPtr<MediaStreamTrack> track =
aOutputStream.mStream->CreateDOMTrack(destinationTrackID, type, source);
if (aAsyncAddtrack) {
mMainThreadEventTarget->Dispatch(
NewRunnableMethod<StoreRefPtrPassByPtr<MediaStreamTrack>>(
"DOMMediaStream::AddTrackInternal",
- aOutputStream.mStream, &DOMMediaStream::AddTrackInternal, track));
+ aOutputStream.mStream,
+ &DOMMediaStream::AddTrackInternal,
+ track));
} else {
aOutputStream.mStream->AddTrackInternal(track);
}
// Track is muted initially, so we don't leak data if it's added while paused
// and an MSG iteration passes before the mute comes into effect.
processedOutputSource->SetTrackEnabled(destinationTrackID,
DisabledTrackMode::SILENCE_FREEZE);
- RefPtr<MediaInputPort> port =
- inputTrack->ForwardTrackContentsTo(processedOutputSource,
- destinationTrackID);
+ RefPtr<MediaInputPort> port = inputTrack->ForwardTrackContentsTo(
+ processedOutputSource, destinationTrackID);
Pair<nsString, RefPtr<MediaInputPort>> p(aTrack->GetId(), port);
aOutputStream.mTrackPorts.AppendElement(Move(p));
if (mSrcStreamIsPlaying) {
processedOutputSource->SetTrackEnabled(destinationTrackID,
DisabledTrackMode::ENABLED);
}
LOG(LogLevel::Debug,
("Created %s track %p with id %d from track %p through MediaInputPort %p",
inputTrack->AsAudioStreamTrack() ? "audio" : "video",
- track.get(), destinationTrackID, inputTrack, port.get()));
+ track.get(),
+ destinationTrackID,
+ inputTrack,
+ port.get()));
}
bool
HTMLMediaElement::CanBeCaptured(StreamCaptureType aCaptureType)
{
// Don't bother capturing when the document has gone away
nsPIDOMWindowInner* window = OwnerDoc()->GetInnerWindow();
if (!window) {
@@ -3450,74 +3545,78 @@ HTMLMediaElement::CaptureStreamInternal(
// We don't support routing to a different graph.
if (!mOutputStreams.IsEmpty() &&
aGraph != mOutputStreams[0].mStream->GetInputStream()->Graph()) {
return nullptr;
}
OutputMediaStream* out = mOutputStreams.AppendElement();
- MediaStreamTrackSourceGetter* getter = new CaptureStreamTrackSourceGetter(this);
+ MediaStreamTrackSourceGetter* getter =
+ new CaptureStreamTrackSourceGetter(this);
nsPIDOMWindowInner* window = OwnerDoc()->GetInnerWindow();
- out->mStream = DOMMediaStream::CreateTrackUnionStreamAsInput(window, aGraph, getter);
+ out->mStream =
+ DOMMediaStream::CreateTrackUnionStreamAsInput(window, aGraph, getter);
out->mStream->SetInactiveOnFinish();
- out->mFinishWhenEnded = aFinishBehavior == StreamCaptureBehavior::FINISH_WHEN_ENDED;
- out->mCapturingAudioOnly = aStreamCaptureType == StreamCaptureType::CAPTURE_AUDIO;
+ out->mFinishWhenEnded =
+ aFinishBehavior == StreamCaptureBehavior::FINISH_WHEN_ENDED;
+ out->mCapturingAudioOnly =
+ aStreamCaptureType == StreamCaptureType::CAPTURE_AUDIO;
if (aStreamCaptureType == StreamCaptureType::CAPTURE_AUDIO) {
if (mSrcStream) {
// We don't support applying volume and mute to the captured stream, when
// capturing a MediaStream.
- nsContentUtils::ReportToConsole(nsIScriptError::errorFlag,
- NS_LITERAL_CSTRING("Media"),
- OwnerDoc(),
- nsContentUtils::eDOM_PROPERTIES,
- "MediaElementAudioCaptureOfMediaStreamError");
+ nsContentUtils::ReportToConsole(
+ nsIScriptError::errorFlag,
+ NS_LITERAL_CSTRING("Media"),
+ OwnerDoc(),
+ nsContentUtils::eDOM_PROPERTIES,
+ "MediaElementAudioCaptureOfMediaStreamError");
return nullptr;
}
// mAudioCaptured tells the user that the audio played by this media element
// is being routed to the captureStreams *instead* of being played to
// speakers.
mAudioCaptured = true;
}
if (mDecoder) {
out->mCapturingDecoder = true;
- mDecoder->AddOutputStream(out->mStream->GetInputStream()->AsProcessedStream(),
- aFinishBehavior == StreamCaptureBehavior::FINISH_WHEN_ENDED);
+ mDecoder->AddOutputStream(
+ out->mStream->GetInputStream()->AsProcessedStream(),
+ aFinishBehavior == StreamCaptureBehavior::FINISH_WHEN_ENDED);
} else if (mSrcStream) {
out->mCapturingMediaStream = true;
}
if (mReadyState == HAVE_NOTHING) {
// Do not expose the tracks until we have metadata.
RefPtr<DOMMediaStream> result = out->mStream;
return result.forget();
}
if (mDecoder) {
if (HasAudio()) {
TrackID audioTrackId = mMediaInfo.mAudio.mTrackId;
RefPtr<MediaStreamTrackSource> trackSource =
getter->GetMediaStreamTrackSource(audioTrackId);
- RefPtr<MediaStreamTrack> track =
- out->mStream->CreateDOMTrack(audioTrackId, MediaSegment::AUDIO,
- trackSource);
+ RefPtr<MediaStreamTrack> track = out->mStream->CreateDOMTrack(
+ audioTrackId, MediaSegment::AUDIO, trackSource);
out->mStream->AddTrackInternal(track);
LOG(LogLevel::Debug,
("Created audio track %d for captured decoder", audioTrackId));
}
if (IsVideo() && HasVideo() && !out->mCapturingAudioOnly) {
TrackID videoTrackId = mMediaInfo.mVideo.mTrackId;
RefPtr<MediaStreamTrackSource> trackSource =
getter->GetMediaStreamTrackSource(videoTrackId);
- RefPtr<MediaStreamTrack> track =
- out->mStream->CreateDOMTrack(videoTrackId, MediaSegment::VIDEO,
- trackSource);
+ RefPtr<MediaStreamTrack> track = out->mStream->CreateDOMTrack(
+ videoTrackId, MediaSegment::VIDEO, trackSource);
out->mStream->AddTrackInternal(track);
LOG(LogLevel::Debug,
("Created video track %d for captured decoder", videoTrackId));
}
}
if (mSrcStream) {
for (size_t i = 0; i < AudioTracks()->Length(); ++i) {
@@ -3537,18 +3636,17 @@ HTMLMediaElement::CaptureStreamInternal(
}
}
}
RefPtr<DOMMediaStream> result = out->mStream;
return result.forget();
}
already_AddRefed<DOMMediaStream>
-HTMLMediaElement::CaptureAudio(ErrorResult& aRv,
- MediaStreamGraph* aGraph)
+HTMLMediaElement::CaptureAudio(ErrorResult& aRv, MediaStreamGraph* aGraph)
{
MOZ_RELEASE_ASSERT(aGraph);
if (!CanBeCaptured(StreamCaptureType::CAPTURE_AUDIO)) {
aRv.Throw(NS_ERROR_FAILURE);
return nullptr;
}
@@ -3566,17 +3664,16 @@ HTMLMediaElement::CaptureAudio(ErrorResu
already_AddRefed<DOMMediaStream>
HTMLMediaElement::MozCaptureStream(ErrorResult& aRv)
{
MediaStreamGraph::GraphDriverType graphDriverType =
HasAudio() ? MediaStreamGraph::AUDIO_THREAD_DRIVER
: MediaStreamGraph::SYSTEM_THREAD_DRIVER;
-
nsPIDOMWindowInner* window = OwnerDoc()->GetInnerWindow();
if (!window) {
aRv.Throw(NS_ERROR_FAILURE);
return nullptr;
}
if (!CanBeCaptured(StreamCaptureType::CAPTURE_ALL_TRACKS)) {
aRv.Throw(NS_ERROR_FAILURE);
@@ -3626,27 +3723,33 @@ HTMLMediaElement::MozCaptureStreamUntilE
if (!stream) {
aRv.Throw(NS_ERROR_FAILURE);
return nullptr;
}
return stream.forget();
}
-NS_IMETHODIMP HTMLMediaElement::GetMozAudioCaptured(bool* aCaptured)
+NS_IMETHODIMP
+HTMLMediaElement::GetMozAudioCaptured(bool* aCaptured)
{
*aCaptured = MozAudioCaptured();
return NS_OK;
}
-class MediaElementSetForURI : public nsURIHashKey {
+class MediaElementSetForURI : public nsURIHashKey
+{
public:
- explicit MediaElementSetForURI(const nsIURI* aKey) : nsURIHashKey(aKey) {}
+ explicit MediaElementSetForURI(const nsIURI* aKey)
+ : nsURIHashKey(aKey)
+ {}
MediaElementSetForURI(const MediaElementSetForURI& toCopy)
- : nsURIHashKey(toCopy), mElements(toCopy.mElements) {}
+ : nsURIHashKey(toCopy)
+ , mElements(toCopy.mElements)
+ {}
nsTArray<HTMLMediaElement*> mElements;
};
typedef nsTHashtable<MediaElementSetForURI> MediaElementURITable;
// Elements in this table must have non-null mDecoder and mLoadingSrc, and those
// can't change while the element is in the table. The table is keyed by
// the element's mLoadingSrc. Each entry has a list of all elements with the
// same mLoadingSrc.
@@ -3692,24 +3795,26 @@ MediaElementTableCount(HTMLMediaElement*
return uriCount;
}
#endif
void
HTMLMediaElement::AddMediaElementToURITable()
{
NS_ASSERTION(mDecoder, "Call this only with decoder Load called");
- NS_ASSERTION(MediaElementTableCount(this, mLoadingSrc) == 0,
+ NS_ASSERTION(
+ MediaElementTableCount(this, mLoadingSrc) == 0,
"Should not have entry for element in element table before addition");
if (!gElementTable) {
gElementTable = new MediaElementURITable();
}
MediaElementSetForURI* entry = gElementTable->PutEntry(mLoadingSrc);
entry->mElements.AppendElement(this);
- NS_ASSERTION(MediaElementTableCount(this, mLoadingSrc) == 1,
+ NS_ASSERTION(
+ MediaElementTableCount(this, mLoadingSrc) == 1,
"Should have a single entry for element in element table after addition");
}
void
HTMLMediaElement::RemoveMediaElementFromURITable()
{
if (!mDecoder || !mLoadingSrc || !gElementTable) {
return;
@@ -3722,17 +3827,17 @@ HTMLMediaElement::RemoveMediaElementFrom
if (entry->mElements.IsEmpty()) {
gElementTable->RemoveEntry(entry);
if (gElementTable->Count() == 0) {
delete gElementTable;
gElementTable = nullptr;
}
}
NS_ASSERTION(MediaElementTableCount(this, mLoadingSrc) == 0,
- "After remove, should no longer have an entry in element table");
+ "After remove, should no longer have an entry in element table");
}
HTMLMediaElement*
HTMLMediaElement::LookupMediaElementURITable(nsIURI* aURI)
{
if (!gElementTable) {
return nullptr;
}
@@ -3740,168 +3845,177 @@ HTMLMediaElement::LookupMediaElementURIT
if (!entry) {
return nullptr;
}
for (uint32_t i = 0; i < entry->mElements.Length(); ++i) {
HTMLMediaElement* elem = entry->mElements[i];
bool equal;
// Look for elements that have the same principal and CORS mode.
// Ditto for anything else that could cause us to send different headers.
- if (NS_SUCCEEDED(elem->NodePrincipal()->Equals(NodePrincipal(), &equal)) && equal &&
- elem->mCORSMode == mCORSMode) {
+ if (NS_SUCCEEDED(elem->NodePrincipal()->Equals(NodePrincipal(), &equal)) &&
+ equal && elem->mCORSMode == mCORSMode) {
// See SetupDecoder() below. We only add a element to the table when
// mDecoder is a ChannelMediaDecoder.
auto decoder = static_cast<ChannelMediaDecoder*>(elem->mDecoder.get());
NS_ASSERTION(decoder, "Decoder gone");
if (decoder->CanClone()) {
return elem;
}
}
}
return nullptr;
}
-class HTMLMediaElement::ShutdownObserver : public nsIObserver {
- enum class Phase : int8_t {
+class HTMLMediaElement::ShutdownObserver : public nsIObserver
+{
+ enum class Phase : int8_t
+ {
Init,
Subscribed,
Unsubscribed
};
+
public:
NS_DECL_ISUPPORTS
- NS_IMETHOD Observe(nsISupports*, const char* aTopic, const char16_t*) override {
+ NS_IMETHOD Observe(nsISupports*, const char* aTopic, const char16_t*) override
+ {
MOZ_DIAGNOSTIC_ASSERT(mPhase == Phase::Subscribed);
MOZ_DIAGNOSTIC_ASSERT(mWeak);
if (strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID) == 0) {
mWeak->NotifyShutdownEvent();
}
return NS_OK;
}
- void Subscribe(HTMLMediaElement* aPtr) {
+ void Subscribe(HTMLMediaElement* aPtr)
+ {
MOZ_DIAGNOSTIC_ASSERT(mPhase == Phase::Init);
MOZ_DIAGNOSTIC_ASSERT(!mWeak);
mWeak = aPtr;
nsContentUtils::RegisterShutdownObserver(this);
mPhase = Phase::Subscribed;
}
- void Unsubscribe() {
+ void Unsubscribe()
+ {
MOZ_DIAGNOSTIC_ASSERT(mPhase == Phase::Subscribed);
MOZ_DIAGNOSTIC_ASSERT(mWeak);
mWeak = nullptr;
nsContentUtils::UnregisterShutdownObserver(this);
mPhase = Phase::Unsubscribed;
}
- void AddRefMediaElement() {
- mWeak->AddRef();
- }
- void ReleaseMediaElement() {
- mWeak->Release();
- }
+ void AddRefMediaElement() { mWeak->AddRef(); }
+ void ReleaseMediaElement() { mWeak->Release(); }
+
private:
- virtual ~ShutdownObserver() {
+ virtual ~ShutdownObserver()
+ {
MOZ_DIAGNOSTIC_ASSERT(mPhase == Phase::Unsubscribed);
MOZ_DIAGNOSTIC_ASSERT(!mWeak);
}
// Guaranteed to be valid by HTMLMediaElement.
HTMLMediaElement* mWeak = nullptr;
Phase mPhase = Phase::Init;
};
NS_IMPL_ISUPPORTS(HTMLMediaElement::ShutdownObserver, nsIObserver)
-HTMLMediaElement::HTMLMediaElement(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo)
- : nsGenericHTMLElement(aNodeInfo),
- mMainThreadEventTarget(OwnerDoc()->EventTargetFor(TaskCategory::Other)),
- mAbstractMainThread(OwnerDoc()->AbstractMainThreadFor(TaskCategory::Other)),
- mWatchManager(this, mAbstractMainThread),
- mSrcStreamTracksAvailable(false),
- mSrcStreamPausedCurrentTime(-1),
- mShutdownObserver(new ShutdownObserver),
- mSourcePointer(nullptr),
- mNetworkState(nsIDOMHTMLMediaElement::NETWORK_EMPTY),
- mReadyState(nsIDOMHTMLMediaElement::HAVE_NOTHING, "HTMLMediaElement::mReadyState"),
- mCurrentLoadID(0),
- mLoadWaitStatus(NOT_WAITING),
- mVolume(1.0),
- mIsAudioTrackAudible(false),
- mMuted(0),
- mPreloadAction(PRELOAD_UNDEFINED),
- mLastCurrentTime(0.0),
- mFragmentStart(-1.0),
- mFragmentEnd(-1.0),
- mDefaultPlaybackRate(1.0),
- mPlaybackRate(1.0),
- mPreservesPitch(true),
- mPlayed(new TimeRanges(ToSupports(OwnerDoc()))),
- mCurrentPlayRangeStart(-1.0),
- mBegun(false),
- mLoadedDataFired(false),
- mAutoplaying(true),
- mAutoplayEnabled(true),
- mPaused(true, *this),
- mStatsShowing(false),
- mAllowCasting(false),
- mIsCasting(false),
- mAudioCaptured(false),
- mPlayingBeforeSeek(false),
- mPausedForInactiveDocumentOrChannel(false),
- mEventDeliveryPaused(false),
- mIsRunningLoadMethod(false),
- mIsDoingExplicitLoad(false),
- mIsLoadingFromSourceChildren(false),
- mDelayingLoadEvent(false),
- mIsRunningSelectResource(false),
- mHaveQueuedSelectResource(false),
- mSuspendedAfterFirstFrame(false),
- mAllowSuspendAfterFirstFrame(true),
- mHasPlayedOrSeeked(false),
- mHasSelfReference(false),
- mShuttingDown(false),
- mSuspendedForPreloadNone(false),
- mSrcStreamIsPlaying(false),
- mMediaSecurityVerified(false),
- mCORSMode(CORS_NONE),
- mIsEncrypted(false),
- mWaitingForKey(NOT_WAITING_FOR_KEY),
- mDownloadSuspendedByCache(false, "HTMLMediaElement::mDownloadSuspendedByCache"),
- mDisableVideo(false),
- mHasUserInteraction(false),
- mFirstFrameLoaded(false),
- mDefaultPlaybackStartPosition(0.0),
- mHasSuspendTaint(false),
- mMediaTracksConstructed(false),
- mVisibilityState(Visibility::UNTRACKED),
- mErrorSink(new ErrorSink(this)),
- mAudioChannelWrapper(new AudioChannelAgentCallback(this))
+HTMLMediaElement::HTMLMediaElement(
+ already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo)
+ : nsGenericHTMLElement(aNodeInfo)
+ , mMainThreadEventTarget(OwnerDoc()->EventTargetFor(TaskCategory::Other))
+ , mAbstractMainThread(OwnerDoc()->AbstractMainThreadFor(TaskCategory::Other))
+ , mWatchManager(this, mAbstractMainThread)
+ , mSrcStreamTracksAvailable(false)
+ , mSrcStreamPausedCurrentTime(-1)
+ , mShutdownObserver(new ShutdownObserver)
+ , mSourcePointer(nullptr)
+ , mNetworkState(nsIDOMHTMLMediaElement::NETWORK_EMPTY)
+ , mReadyState(nsIDOMHTMLMediaElement::HAVE_NOTHING,
+ "HTMLMediaElement::mReadyState")
+ , mCurrentLoadID(0)
+ , mLoadWaitStatus(NOT_WAITING)
+ , mVolume(1.0)
+ , mIsAudioTrackAudible(false)
+ , mMuted(0)
+ , mPreloadAction(PRELOAD_UNDEFINED)
+ , mLastCurrentTime(0.0)
+ , mFragmentStart(-1.0)
+ , mFragmentEnd(-1.0)
+ , mDefaultPlaybackRate(1.0)
+ , mPlaybackRate(1.0)
+ , mPreservesPitch(true)
+ , mPlayed(new TimeRanges(ToSupports(OwnerDoc())))
+ , mCurrentPlayRangeStart(-1.0)
+ , mBegun(false)
+ , mLoadedDataFired(false)
+ , mAutoplaying(true)
+ , mAutoplayEnabled(true)
+ , mPaused(true, *this)
+ , mStatsShowing(false)
+ , mAllowCasting(false)
+ , mIsCasting(false)
+ , mAudioCaptured(false)
+ , mPlayingBeforeSeek(false)
+ , mPausedForInactiveDocumentOrChannel(false)
+ , mEventDeliveryPaused(false)
+ , mIsRunningLoadMethod(false)
+ , mIsDoingExplicitLoad(false)
+ , mIsLoadingFromSourceChildren(false)
+ , mDelayingLoadEvent(false)
+ , mIsRunningSelectResource(false)
+ , mHaveQueuedSelectResource(false)
+ , mSuspendedAfterFirstFrame(false)
+ , mAllowSuspendAfterFirstFrame(true)
+ , mHasPlayedOrSeeked(false)
+ , mHasSelfReference(false)
+ , mShuttingDown(false)
+ , mSuspendedForPreloadNone(false)
+ , mSrcStreamIsPlaying(false)
+ , mMediaSecurityVerified(false)
+ , mCORSMode(CORS_NONE)
+ , mIsEncrypted(false)
+ , mWaitingForKey(NOT_WAITING_FOR_KEY)
+ , mDownloadSuspendedByCache(false,
+ "HTMLMediaElement::mDownloadSuspendedByCache")
+ , mDisableVideo(false)
+ , mHasUserInteraction(false)
+ , mFirstFrameLoaded(false)
+ , mDefaultPlaybackStartPosition(0.0)
+ , mHasSuspendTaint(false)
+ , mMediaTracksConstructed(false)
+ , mVisibilityState(Visibility::UNTRACKED)
+ , mErrorSink(new ErrorSink(this))
+ , mAudioChannelWrapper(new AudioChannelAgentCallback(this))
{
MOZ_ASSERT(mMainThreadEventTarget);
MOZ_ASSERT(mAbstractMainThread);
ErrorResult rv;
double defaultVolume = Preferences::GetFloat("media.default_volume", 1.0);
SetVolume(defaultVolume, rv);
RegisterActivityObserver();
NotifyOwnerDocumentActivityChanged();
MOZ_ASSERT(NS_IsMainThread());
- mWatchManager.Watch(mDownloadSuspendedByCache, &HTMLMediaElement::UpdateReadyStateInternal);
+ mWatchManager.Watch(mDownloadSuspendedByCache,
+ &HTMLMediaElement::UpdateReadyStateInternal);
// Paradoxically, there is a self-edge whereby UpdateReadyStateInternal refuses
// to run until mReadyState reaches at least HAVE_METADATA by some other means.
mWatchManager.Watch(mReadyState, &HTMLMediaElement::UpdateReadyStateInternal);
mShutdownObserver->Subscribe(this);
}
HTMLMediaElement::~HTMLMediaElement()
{
- NS_ASSERTION(!mHasSelfReference,
- "How can we be destroyed if we're still holding a self reference?");
+ NS_ASSERTION(
+ !mHasSelfReference,
+ "How can we be destroyed if we're still holding a self reference?");
mShutdownObserver->Unsubscribe();
if (mVideoFrameContainer) {
mVideoFrameContainer->ForgetElement();
}
UnregisterActivityObserver();
if (mDecoder) {
@@ -3919,57 +4033,58 @@ HTMLMediaElement::~HTMLMediaElement()
}
if (mCaptureStreamPort) {
mCaptureStreamPort->Destroy();
mCaptureStreamPort = nullptr;
}
NS_ASSERTION(MediaElementTableCount(this, mLoadingSrc) == 0,
- "Destroyed media element should no longer be in element table");
+ "Destroyed media element should no longer be in element table");
if (mChannelLoader) {
mChannelLoader->Cancel();
}
if (mAudioChannelWrapper) {
mAudioChannelWrapper->Shutdown();
mAudioChannelWrapper = nullptr;
}
WakeLockRelease();
}
-void HTMLMediaElement::StopSuspendingAfterFirstFrame()
+void
+HTMLMediaElement::StopSuspendingAfterFirstFrame()
{
mAllowSuspendAfterFirstFrame = false;
if (!mSuspendedAfterFirstFrame)
return;
mSuspendedAfterFirstFrame = false;
if (mDecoder) {
mDecoder->Resume();
}
}
-void HTMLMediaElement::SetPlayedOrSeeked(bool aValue)
+void
+HTMLMediaElement::SetPlayedOrSeeked(bool aValue)
{
if (aValue == mHasPlayedOrSeeked) {
return;
}
mHasPlayedOrSeeked = aValue;
// Force a reflow so that the poster frame hides or shows immediately.
nsIFrame* frame = GetPrimaryFrame();
if (!frame) {
return;
}
- frame->PresContext()->PresShell()->FrameNeedsReflow(frame,
- nsIPresShell::eTreeChange,
- NS_FRAME_IS_DIRTY);
+ frame->PresContext()->PresShell()->FrameNeedsReflow(
+ frame, nsIPresShell::eTreeChange, NS_FRAME_IS_DIRTY);
}
void
HTMLMediaElement::NotifyXPCOMShutdown()
{
ShutdownDecoder();
}
@@ -4115,29 +4230,29 @@ HTMLMediaElement::PlayInternal(ErrorResu
// 6.4. If the media element's readyState attribute has the value
// HAVE_NOTHING, HAVE_METADATA, or HAVE_CURRENT_DATA, queue a task to
// fire a simple event named waiting at the element.
// Otherwise, the media element's readyState attribute has the value
// HAVE_FUTURE_DATA or HAVE_ENOUGH_DATA: notify about playing for the
// element.
switch (mReadyState) {
- case nsIDOMHTMLMediaElement::HAVE_NOTHING:
- DispatchAsyncEvent(NS_LITERAL_STRING("waiting"));
- break;
- case nsIDOMHTMLMediaElement::HAVE_METADATA:
- case nsIDOMHTMLMediaElement::HAVE_CURRENT_DATA:
- FireTimeUpdate(false);
- DispatchAsyncEvent(NS_LITERAL_STRING("waiting"));
- break;
- case nsIDOMHTMLMediaElement::HAVE_FUTURE_DATA:
- case nsIDOMHTMLMediaElement::HAVE_ENOUGH_DATA:
- FireTimeUpdate(false);
- NotifyAboutPlaying();
- break;
+ case nsIDOMHTMLMediaElement::HAVE_NOTHING:
+ DispatchAsyncEvent(NS_LITERAL_STRING("waiting"));
+ break;
+ case nsIDOMHTMLMediaElement::HAVE_METADATA:
+ case nsIDOMHTMLMediaElement::HAVE_CURRENT_DATA:
+ FireTimeUpdate(false);
+ DispatchAsyncEvent(NS_LITERAL_STRING("waiting"));
+ break;
+ case nsIDOMHTMLMediaElement::HAVE_FUTURE_DATA:
+ case nsIDOMHTMLMediaElement::HAVE_ENOUGH_DATA:
+ FireTimeUpdate(false);
+ NotifyAboutPlaying();
+ break;
}
} else if (mReadyState >= nsIDOMHTMLMediaElement::HAVE_FUTURE_DATA) {
// 7. Otherwise, if the media element's readyState attribute has the value
// HAVE_FUTURE_DATA or HAVE_ENOUGH_DATA, take pending play promises and
// queue a task to resolve pending play promises with the result.
AsyncResolvePendingPlayPromises();
}
@@ -4168,19 +4283,18 @@ HTMLMediaElement::WakeLockBoolWrapper::o
}
void
HTMLMediaElement::WakeLockBoolWrapper::UpdateWakeLock()
{
MOZ_ASSERT(NS_IsMainThread());
bool playing = !mValue;
- bool isAudible = mOuter.Volume() > 0.0 &&
- !mOuter.mMuted &&
- mOuter.mIsAudioTrackAudible;
+ bool isAudible =
+ mOuter.Volume() > 0.0 && !mOuter.mMuted && mOuter.mIsAudioTrackAudible;
// when playing audible media.
if (playing && isAudible) {
mOuter.WakeLockCreate();
} else {
mOuter.WakeLockRelease();
}
}
@@ -4188,19 +4302,18 @@ void
HTMLMediaElement::WakeLockCreate()
{
if (!mWakeLock) {
RefPtr<power::PowerManagerService> pmService =
power::PowerManagerService::GetInstance();
NS_ENSURE_TRUE_VOID(pmService);
ErrorResult rv;
- mWakeLock = pmService->NewWakeLock(NS_LITERAL_STRING("audio-playing"),
- OwnerDoc()->GetInnerWindow(),
- rv);
+ mWakeLock = pmService->NewWakeLock(
+ NS_LITERAL_STRING("audio-playing"), OwnerDoc()->GetInnerWindow(), rv);
}
}
void
HTMLMediaElement::WakeLockRelease()
{
if (mWakeLock) {
ErrorResult rv;
@@ -4210,84 +4323,92 @@ HTMLMediaElement::WakeLockRelease()
}
}
HTMLMediaElement::OutputMediaStream::OutputMediaStream()
: mFinishWhenEnded(false)
, mCapturingAudioOnly(false)
, mCapturingDecoder(false)
, mCapturingMediaStream(false)
- , mNextAvailableTrackID(1) {}
+ , mNextAvailableTrackID(1)
+{}
HTMLMediaElement::OutputMediaStream::~OutputMediaStream()
{
for (auto pair : mTrackPorts) {
pair.second()->Destroy();
}
}
-bool HTMLMediaElement::ParseAttribute(int32_t aNamespaceID,
- nsIAtom* aAttribute,
- const nsAString& aValue,
- nsAttrValue& aResult)
+bool
+HTMLMediaElement::ParseAttribute(int32_t aNamespaceID,
+ nsIAtom* aAttribute,
+ const nsAString& aValue,
+ nsAttrValue& aResult)
{
// Mappings from 'preload' attribute strings to an enumeration.
static const nsAttrValue::EnumTable kPreloadTable[] = {
- { "", HTMLMediaElement::PRELOAD_ATTR_EMPTY },
- { "none", HTMLMediaElement::PRELOAD_ATTR_NONE },
+ { "", HTMLMediaElement::PRELOAD_ATTR_EMPTY },
+ { "none", HTMLMediaElement::PRELOAD_ATTR_NONE },
{ "metadata", HTMLMediaElement::PRELOAD_ATTR_METADATA },
- { "auto", HTMLMediaElement::PRELOAD_ATTR_AUTO },
- { nullptr, 0 }
+ { "auto", HTMLMediaElement::PRELOAD_ATTR_AUTO },
+ { nullptr, 0 }
};
if (aNamespaceID == kNameSpaceID_None) {
if (ParseImageAttribute(aAttribute, aValue, aResult)) {
return true;
}
if (aAttribute == nsGkAtoms::crossorigin) {
ParseCORSValue(aValue, aResult);
return true;
}
if (aAttribute == nsGkAtoms::preload) {
return aResult.ParseEnumValue(aValue, kPreloadTable, false);
}
}
- return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
- aResult);
-}
-
-void HTMLMediaElement::DoneCreatingElement()
-{
- if (HasAttr(kNameSpaceID_None, nsGkAtoms::muted)) {
- mMuted |= MUTED_BY_CONTENT;
- }
-}
-
-bool HTMLMediaElement::IsHTMLFocusable(bool aWithMouse,
- bool* aIsFocusable,
- int32_t* aTabIndex)
-{
- if (nsGenericHTMLElement::IsHTMLFocusable(aWithMouse, aIsFocusable, aTabIndex)) {
+ return nsGenericHTMLElement::ParseAttribute(
+ aNamespaceID, aAttribute, aValue, aResult);
+}
+
+void
+HTMLMediaElement::DoneCreatingElement()
+{
+ if (HasAttr(kNameSpaceID_None, nsGkAtoms::muted)) {
+ mMuted |= MUTED_BY_CONTENT;
+ }
+}
+
+bool
+HTMLMediaElement::IsHTMLFocusable(bool aWithMouse,
+ bool* aIsFocusable,
+ int32_t* aTabIndex)
+{
+ if (nsGenericHTMLElement::IsHTMLFocusable(
+ aWithMouse, aIsFocusable, aTabIndex)) {
return true;
}
*aIsFocusable = true;
return false;
}
-int32_t HTMLMediaElement::TabIndexDefault()
+int32_t
+HTMLMediaElement::TabIndexDefault()
{
return 0;
}
nsresult
-HTMLMediaElement::AfterSetAttr(int32_t aNameSpaceID, nsIAtom* aName,
- const nsAttrValue* aValue,
- const nsAttrValue* aOldValue, bool aNotify)
+HTMLMediaElement::AfterSetAttr(int32_t aNameSpaceID,
+ nsIAtom* aName,
+ const nsAttrValue* aValue,
+ const nsAttrValue* aOldValue,
+ bool aNotify)
{
if (aNameSpaceID == kNameSpaceID_None) {
if (aName == nsGkAtoms::src) {
mSrcMediaSource = nullptr;
if (aValue) {
nsString srcStr = aValue->GetStringValue();
nsCOMPtr<nsIURI> uri;
NewURIFromString(srcStr, getter_AddRefs(uri));
@@ -4322,93 +4443,101 @@ HTMLMediaElement::AfterSetAttr(int32_t a
}
// Since AfterMaybeChangeAttr may call DoLoad, make sure that it is called
// *after* any possible changes to mSrcMediaSource.
if (aValue) {
AfterMaybeChangeAttr(aNameSpaceID, aName, aNotify);
}
- return nsGenericHTMLElement::AfterSetAttr(aNameSpaceID, aName,
- aValue, aOldValue, aNotify);
+ return nsGenericHTMLElement::AfterSetAttr(
+ aNameSpaceID, aName, aValue, aOldValue, aNotify);
}
nsresult
-HTMLMediaElement::OnAttrSetButNotChanged(int32_t aNamespaceID, nsIAtom* aName,
+HTMLMediaElement::OnAttrSetButNotChanged(int32_t aNamespaceID,
+ nsIAtom* aName,
const nsAttrValueOrString& aValue,
bool aNotify)
{
AfterMaybeChangeAttr(aNamespaceID, aName, aNotify);
- return nsGenericHTMLElement::OnAttrSetButNotChanged(aNamespaceID, aName,
- aValue, aNotify);
-}
-
-void
-HTMLMediaElement::AfterMaybeChangeAttr(int32_t aNamespaceID, nsIAtom* aName,
+ return nsGenericHTMLElement::OnAttrSetButNotChanged(
+ aNamespaceID, aName, aValue, aNotify);
+}
+
+void
+HTMLMediaElement::AfterMaybeChangeAttr(int32_t aNamespaceID,
+ nsIAtom* aName,
bool aNotify)
{
if (aNamespaceID == kNameSpaceID_None) {
if (aName == nsGkAtoms::src) {
DoLoad();
}
}
}
-nsresult HTMLMediaElement::BindToTree(nsIDocument* aDocument, nsIContent* aParent,
- nsIContent* aBindingParent,
- bool aCompileEventHandlers)
-{
- nsresult rv = nsGenericHTMLElement::BindToTree(aDocument,
- aParent,
- aBindingParent,
- aCompileEventHandlers);
+nsresult
+HTMLMediaElement::BindToTree(nsIDocument* aDocument,
+ nsIContent* aParent,
+ nsIContent* aBindingParent,
+ bool aCompileEventHandlers)
+{
+ nsresult rv = nsGenericHTMLElement::BindToTree(
+ aDocument, aParent, aBindingParent, aCompileEventHandlers);
mUnboundFromTree = false;
if (aDocument) {
- mAutoplayEnabled =
- IsAutoplayEnabled() && (!aDocument || !aDocument->IsStaticDocument()) &&
- !IsEditable();
+ mAutoplayEnabled = IsAutoplayEnabled() &&
+ (!aDocument || !aDocument->IsStaticDocument()) &&
+ !IsEditable();
// The preload action depends on the value of the autoplay attribute.
// It's value may have changed, so update it.
UpdatePreloadAction();
}
NotifyDecoderActivityChanges();
return rv;
}
/* static */
-void HTMLMediaElement::VideoDecodeSuspendTimerCallback(nsITimer* aTimer, void* aClosure)
+void
+HTMLMediaElement::VideoDecodeSuspendTimerCallback(nsITimer* aTimer,
+ void* aClosure)
{
MOZ_ASSERT(NS_IsMainThread());
auto element = static_cast<HTMLMediaElement*>(aClosure);
element->mVideoDecodeSuspendTime.Start();
element->mVideoDecodeSuspendTimer = nullptr;
}
-void HTMLMediaElement::HiddenVideoStart()
+void
+HTMLMediaElement::HiddenVideoStart()
{
MOZ_ASSERT(NS_IsMainThread());
mHiddenPlayTime.Start();
if (mVideoDecodeSuspendTimer) {
// Already started, just keep it running.
return;
}
mVideoDecodeSuspendTimer = do_CreateInstance("@mozilla.org/timer;1");
mVideoDecodeSuspendTimer->SetTarget(mMainThreadEventTarget);
mVideoDecodeSuspendTimer->InitWithNamedFuncCallback(
- VideoDecodeSuspendTimerCallback, this,
- MediaPrefs::MDSMSuspendBackgroundVideoDelay(), nsITimer::TYPE_ONE_SHOT,
+ VideoDecodeSuspendTimerCallback,
+ this,
+ MediaPrefs::MDSMSuspendBackgroundVideoDelay(),
+ nsITimer::TYPE_ONE_SHOT,
"HTMLMediaElement::VideoDecodeSuspendTimerCallback");
}
-void HTMLMediaElement::HiddenVideoStop()
+void
+HTMLMediaElement::HiddenVideoStop()
{
MOZ_ASSERT(NS_IsMainThread());
mHiddenPlayTime.Pause();
mVideoDecodeSuspendTime.Pause();
if (!mVideoDecodeSuspendTimer) {
return;
}
mVideoDecodeSuspendTimer->Cancel();
@@ -4417,60 +4546,62 @@ void HTMLMediaElement::HiddenVideoStop()
void
HTMLMediaElement::ReportEMETelemetry()
{
// Report telemetry for EME videos when a page is unloaded.
NS_ASSERTION(NS_IsMainThread(), "Should be on main thread.");
if (mIsEncrypted && Preferences::GetBool("media.eme.enabled")) {
Telemetry::Accumulate(Telemetry::VIDEO_EME_PLAY_SUCCESS, mLoadedDataFired);
- LOG(LogLevel::Debug, ("%p VIDEO_EME_PLAY_SUCCESS = %s",
- this, mLoadedDataFired ? "true" : "false"));
+ LOG(LogLevel::Debug,
+ ("%p VIDEO_EME_PLAY_SUCCESS = %s",
+ this,
+ mLoadedDataFired ? "true" : "false"));
}
}
void
HTMLMediaElement::ReportTelemetry()
{
// Report telemetry for videos when a page is unloaded. We
// want to know data on what state the video is at when
// the user has exited.
- enum UnloadedState {
+ enum UnloadedState
+ {
ENDED = 0,
PAUSED = 1,
STALLED = 2,
SEEKING = 3,
OTHER = 4
};
UnloadedState state = OTHER;
if (Seeking()) {
state = SEEKING;
- }
- else if (Ended()) {
+ } else if (Ended()) {
state = ENDED;
- }
- else if (Paused()) {
+ } else if (Paused()) {
state = PAUSED;
- }
- else {
+ } else {
// For buffering we check if the current playback position is at the end
// of a buffered range, within a margin of error. We also consider to be
// buffering if the last frame status was buffering and the ready state is
// HAVE_CURRENT_DATA to account for times where we are in a buffering state
// regardless of what actual data we have buffered.
bool stalled = false;
RefPtr<TimeRanges> ranges = Buffered();
const double errorMargin = 0.05;
double t = CurrentTime();
TimeRanges::index_type index = ranges->Find(t, errorMargin);
ErrorResult ignore;
stalled = index != TimeRanges::NoIndex &&
(ranges->End(index, ignore) - t) < errorMargin;
- stalled |= mDecoder && NextFrameStatus() == MediaDecoderOwner::NEXT_FRAME_UNAVAILABLE_BUFFERING &&
+ stalled |= mDecoder &&
+ NextFrameStatus() ==
+ MediaDecoderOwner::NEXT_FRAME_UNAVAILABLE_BUFFERING &&
mReadyState == HTMLMediaElement::HAVE_CURRENT_DATA;
if (stalled) {
state = STALLED;
}
}
Telemetry::Accumulate(Telemetry::VIDEO_UNLOAD_STATE, state);
LOG(LogLevel::Debug, ("%p VIDEO_UNLOAD_STATE = %d", this, state));
@@ -4489,123 +4620,135 @@ HTMLMediaElement::ReportTelemetry()
LOG(LogLevel::Debug,
("Reporting telemetry DROPPED_FRAMES_IN_VIDEO_PLAYBACK"));
Telemetry::Accumulate(Telemetry::VIDEO_DROPPED_FRAMES_PROPORTION,
percentage);
}
}
}
- if (mMediaInfo.HasVideo() &&
- mMediaInfo.mVideo.mImage.height > 0) {
+ if (mMediaInfo.HasVideo() && mMediaInfo.mVideo.mImage.height > 0) {
// We have a valid video.
double playTime = mPlayTime.Total();
double hiddenPlayTime = mHiddenPlayTime.Total();
double videoDecodeSuspendTime = mVideoDecodeSuspendTime.Total();
- Telemetry::Accumulate(Telemetry::VIDEO_PLAY_TIME_MS, SECONDS_TO_MS(playTime));
+ Telemetry::Accumulate(Telemetry::VIDEO_PLAY_TIME_MS,
+ SECONDS_TO_MS(playTime));
LOG(LogLevel::Debug, ("%p VIDEO_PLAY_TIME_MS = %f", this, playTime));
- Telemetry::Accumulate(Telemetry::VIDEO_HIDDEN_PLAY_TIME_MS, SECONDS_TO_MS(hiddenPlayTime));
- LOG(LogLevel::Debug, ("%p VIDEO_HIDDEN_PLAY_TIME_MS = %f", this, hiddenPlayTime));
+ Telemetry::Accumulate(Telemetry::VIDEO_HIDDEN_PLAY_TIME_MS,
+ SECONDS_TO_MS(hiddenPlayTime));
+ LOG(LogLevel::Debug,
+ ("%p VIDEO_HIDDEN_PLAY_TIME_MS = %f", this, hiddenPlayTime));
if (playTime > 0.0) {
// We have actually played something -> Report some valid-video telemetry.
// Keyed by audio+video or video alone, and by a resolution range.
nsCString key(mMediaInfo.HasAudio() ? "AV," : "V,");
- static const struct { int32_t mH; const char* mRes; } sResolutions[] = {
- { 240, "0<h<=240" },
- { 480, "240<h<=480" },
- { 576, "480<h<=576" },
- { 720, "576<h<=720" },
- { 1080, "720<h<=1080" },
- { 2160, "1080<h<=2160" }
- };
+ static const struct
+ {
+ int32_t mH;
+ const char* mRes;
+ } sResolutions[] = { { 240, "0<h<=240" }, { 480, "240<h<=480" },
+ { 576, "480<h<=576" }, { 720, "576<h<=720" },
+ { 1080, "720<h<=1080" }, { 2160, "1080<h<=2160" } };
const char* resolution = "h>2160";
int32_t height = mMediaInfo.mVideo.mImage.height;
for (const auto& res : sResolutions) {
if (height <= res.mH) {
resolution = res.mRes;
break;
}
}
key.AppendASCII(resolution);
- uint32_t hiddenPercentage = uint32_t(hiddenPlayTime / playTime * 100.0 + 0.5);
- Telemetry::Accumulate(Telemetry::VIDEO_HIDDEN_PLAY_TIME_PERCENTAGE,
- key,
- hiddenPercentage);
+ uint32_t hiddenPercentage =
+ uint32_t(hiddenPlayTime / playTime * 100.0 + 0.5);
+ Telemetry::Accumulate(
+ Telemetry::VIDEO_HIDDEN_PLAY_TIME_PERCENTAGE, key, hiddenPercentage);
// Also accumulate all percentages in an "All" key.
Telemetry::Accumulate(Telemetry::VIDEO_HIDDEN_PLAY_TIME_PERCENTAGE,
NS_LITERAL_CSTRING("All"),
hiddenPercentage);
- LOG(LogLevel::Debug, ("%p VIDEO_HIDDEN_PLAY_TIME_PERCENTAGE = %u, keys: '%s' and 'All'",
- this, hiddenPercentage, key.get()));
+ LOG(LogLevel::Debug,
+ ("%p VIDEO_HIDDEN_PLAY_TIME_PERCENTAGE = %u, keys: '%s' and 'All'",
+ this,
+ hiddenPercentage,
+ key.get()));
uint32_t videoDecodeSuspendPercentage =
uint32_t(videoDecodeSuspendTime / playTime * 100.0 + 0.5);
Telemetry::Accumulate(Telemetry::VIDEO_INFERRED_DECODE_SUSPEND_PERCENTAGE,
key,
videoDecodeSuspendPercentage);
Telemetry::Accumulate(Telemetry::VIDEO_INFERRED_DECODE_SUSPEND_PERCENTAGE,
NS_LITERAL_CSTRING("All"),
videoDecodeSuspendPercentage);
- LOG(LogLevel::Debug, ("%p VIDEO_INFERRED_DECODE_SUSPEND_PERCENTAGE = %u, keys: '%s' and 'All'",
- this, videoDecodeSuspendPercentage, key.get()));
+ LOG(LogLevel::Debug,
+ ("%p VIDEO_INFERRED_DECODE_SUSPEND_PERCENTAGE = %u, keys: '%s' and "
+ "'All'",
+ this,
+ videoDecodeSuspendPercentage,
+ key.get()));
if (data.mInterKeyframeCount != 0) {
- uint32_t average_ms =
- uint32_t(std::min<uint64_t>(double(data.mInterKeyframeSum_us)
- / double(data.mInterKeyframeCount)
- / 1000.0
- + 0.5,
- UINT32_MAX));
- Telemetry::Accumulate(Telemetry::VIDEO_INTER_KEYFRAME_AVERAGE_MS,
- key,
- average_ms);
+ uint32_t average_ms = uint32_t(
+ std::min<uint64_t>(double(data.mInterKeyframeSum_us) /
+ double(data.mInterKeyframeCount) / 1000.0 +
+ 0.5,
+ UINT32_MAX));
+ Telemetry::Accumulate(
+ Telemetry::VIDEO_INTER_KEYFRAME_AVERAGE_MS, key, average_ms);
Telemetry::Accumulate(Telemetry::VIDEO_INTER_KEYFRAME_AVERAGE_MS,
NS_LITERAL_CSTRING("All"),
average_ms);
- LOG(LogLevel::Debug, ("%p VIDEO_INTER_KEYFRAME_AVERAGE_MS = %u, keys: '%s' and 'All'",
- this, average_ms, key.get()));
-
- uint32_t max_ms =
- uint32_t(std::min<uint64_t>((data.mInterKeyFrameMax_us + 500) / 1000,
- UINT32_MAX));
- Telemetry::Accumulate(Telemetry::VIDEO_INTER_KEYFRAME_MAX_MS,
- key,
- max_ms);
+ LOG(LogLevel::Debug,
+ ("%p VIDEO_INTER_KEYFRAME_AVERAGE_MS = %u, keys: '%s' and 'All'",
+ this,
+ average_ms,
+ key.get()));
+
+ uint32_t max_ms = uint32_t(std::min<uint64_t>(
+ (data.mInterKeyFrameMax_us + 500) / 1000, UINT32_MAX));
+ Telemetry::Accumulate(
+ Telemetry::VIDEO_INTER_KEYFRAME_MAX_MS, key, max_ms);
Telemetry::Accumulate(Telemetry::VIDEO_INTER_KEYFRAME_MAX_MS,
NS_LITERAL_CSTRING("All"),
max_ms);
- LOG(LogLevel::Debug, ("%p VIDEO_INTER_KEYFRAME_MAX_MS = %u, keys: '%s' and 'All'",
- this, max_ms, key.get()));
+ LOG(LogLevel::Debug,
+ ("%p VIDEO_INTER_KEYFRAME_MAX_MS = %u, keys: '%s' and 'All'",
+ this,
+ max_ms,
+ key.get()));
} else {
// Here, we have played *some* of the video, but didn't get more than 1
// keyframe. Report '0' if we have played for longer than the video-
// decode-suspend delay (showing recovery would be difficult).
- uint32_t suspendDelay_ms = MediaPrefs::MDSMSuspendBackgroundVideoDelay();
+ uint32_t suspendDelay_ms =
+ MediaPrefs::MDSMSuspendBackgroundVideoDelay();
if (uint32_t(playTime * 1000.0) > suspendDelay_ms) {
- Telemetry::Accumulate(Telemetry::VIDEO_INTER_KEYFRAME_MAX_MS,
- key,
- 0);
+ Telemetry::Accumulate(Telemetry::VIDEO_INTER_KEYFRAME_MAX_MS, key, 0);
Telemetry::Accumulate(Telemetry::VIDEO_INTER_KEYFRAME_MAX_MS,
NS_LITERAL_CSTRING("All"),
0);
- LOG(LogLevel::Debug, ("%p VIDEO_INTER_KEYFRAME_MAX_MS = 0 (only 1 keyframe), keys: '%s' and 'All'",
- this, key.get()));
+ LOG(LogLevel::Debug,
+ ("%p VIDEO_INTER_KEYFRAME_MAX_MS = 0 (only 1 keyframe), keys: "
+ "'%s' and 'All'",
+ this,
+ key.get()));
}
}
}
}
}
-void HTMLMediaElement::UnbindFromTree(bool aDeep,
- bool aNullParent)
+void
+HTMLMediaElement::UnbindFromTree(bool aDeep, bool aNullParent)
{
mUnboundFromTree = true;
mVisibilityState = Visibility::UNTRACKED;
nsGenericHTMLElement::UnbindFromTree(aDeep, aNullParent);
MOZ_ASSERT(IsHidden());
NotifyDecoderActivityChanges();
@@ -4619,31 +4762,33 @@ void HTMLMediaElement::UnbindFromTree(bo
});
RunInStableState(task);
}
static bool
IsVP9InMP4(const MediaContainerType& aContainerType)
{
const MediaContainerType mimeType(aContainerType.Type());
- return DecoderTraits::IsMP4SupportedType(mimeType,
- /* DecoderDoctorDiagnostics* */ nullptr)
- && IsVP9CodecString(aContainerType.ExtendedType().Codecs().AsString());
+ return DecoderTraits::IsMP4SupportedType(
+ mimeType,
+ /* DecoderDoctorDiagnostics* */ nullptr) &&
+ IsVP9CodecString(aContainerType.ExtendedType().Codecs().AsString());
}
/* static */
CanPlayStatus
HTMLMediaElement::GetCanPlay(const nsAString& aType,
DecoderDoctorDiagnostics* aDiagnostics)
{
Maybe<MediaContainerType> containerType = MakeMediaContainerType(aType);
if (!containerType) {
return CANPLAY_NO;
}
- CanPlayStatus status = DecoderTraits::CanHandleContainerType(*containerType, aDiagnostics);
+ CanPlayStatus status =
+ DecoderTraits::CanHandleContainerType(*containerType, aDiagnostics);
if (status == CANPLAY_YES && IsVP9InMP4(*containerType)) {
// We don't have a demuxer that can handle VP9 in non-fragmented MP4.
// So special-case VP9 in MP4 here, as we assume canPlayType() implies
// non-fragmented MP4 anyway. Note we report that we can play VP9
// in MP4 in MediaSource.isTypeSupported(), as the fragmented MP4
// demuxer can handle VP9 in fragmented MP4.
return CANPLAY_NO;
}
@@ -4653,31 +4798,33 @@ HTMLMediaElement::GetCanPlay(const nsASt
NS_IMETHODIMP
HTMLMediaElement::CanPlayType(const nsAString& aType, nsAString& aResult)
{
DecoderDoctorDiagnostics diagnostics;
CanPlayStatus canPlay = GetCanPlay(aType, &diagnostics);
diagnostics.StoreFormatDiagnostics(
OwnerDoc(), aType, canPlay != CANPLAY_NO, __func__);
switch (canPlay) {
- case CANPLAY_NO:
- aResult.Truncate();
- break;
- case CANPLAY_YES:
- aResult.AssignLiteral("probably");
- break;
- default:
- case CANPLAY_MAYBE:
- aResult.AssignLiteral("maybe");
- break;
- }
-
- LOG(LogLevel::Debug, ("%p CanPlayType(%s) = \"%s\"", this,
- NS_ConvertUTF16toUTF8(aType).get(),
- NS_ConvertUTF16toUTF8(aResult).get()));
+ case CANPLAY_NO:
+ aResult.Truncate();
+ break;
+ case CANPLAY_YES:
+ aResult.AssignLiteral("probably");
+ break;
+ default:
+ case CANPLAY_MAYBE:
+ aResult.AssignLiteral("maybe");
+ break;
+ }
+
+ LOG(LogLevel::Debug,
+ ("%p CanPlayType(%s) = \"%s\"",
+ this,
+ NS_ConvertUTF16toUTF8(aType).get(),
+ NS_ConvertUTF16toUTF8(aResult).get()));
return NS_OK;
}
nsresult
HTMLMediaElement::InitializeDecoderAsClone(ChannelMediaDecoder* aOriginal)
{
NS_ASSERTION(mLoadingSrc, "mLoadingSrc must already be set");
@@ -4692,17 +4839,18 @@ HTMLMediaElement::InitializeDecoderAsClo
mHasSuspendTaint,
HasAttr(kNameSpaceID_None, nsGkAtoms::loop),
aOriginal->ContainerType());
RefPtr<ChannelMediaDecoder> decoder = aOriginal->Clone(decoderInit);
if (!decoder)
return NS_ERROR_FAILURE;
- LOG(LogLevel::Debug, ("%p Cloned decoder %p from %p", this, decoder.get(), aOriginal));
+ LOG(LogLevel::Debug,
+ ("%p Cloned decoder %p from %p", this, decoder.get(), aOriginal));
return FinishDecoderSetup(decoder);
}
template<typename DecoderType, typename... LoadArgs>
nsresult
HTMLMediaElement::SetupDecoder(DecoderType* aDecoder, LoadArgs&&... aArgs)
{
@@ -4726,18 +4874,19 @@ HTMLMediaElement::SetupDecoder(DecoderTy
NS_ASSERTION(
MediaElementTableCount(this, mLoadingSrc) == 1,
"Media element should have single table entry if decode initialized");
}
return rv;
}
-nsresult HTMLMediaElement::InitializeDecoderForChannel(nsIChannel* aChannel,
- nsIStreamListener** aListener)
+nsresult
+HTMLMediaElement::InitializeDecoderForChannel(nsIChannel* aChannel,
+ nsIStreamListener** aListener)
{
NS_ASSERTION(mLoadingSrc, "mLoadingSrc must already be set");
DecoderDoctorDiagnostics diagnostics;
nsAutoCString mimeType;
aChannel->GetContentType(mimeType);
NS_ASSERTION(!mimeType.IsEmpty(), "We should have the Content-Type.");
@@ -4858,45 +5007,45 @@ HTMLMediaElement::FinishDecoderSetup(Med
if (NS_FAILED(rv)) {
ShutdownDecoder();
}
return rv;
}
-class HTMLMediaElement::StreamListener : public MediaStreamListener,
- public WatchTarget
+class HTMLMediaElement::StreamListener
+ : public MediaStreamListener
+ , public WatchTarget
{
public:
- StreamListener(HTMLMediaElement* aElement, const char* aName) :
- WatchTarget(aName),
- mElement(aElement),
- mHaveCurrentData(false),
- mBlocked(false),
- mFinished(false),
- mMutex(aName),
- mPendingNotifyOutput(false)
+ StreamListener(HTMLMediaElement* aElement, const char* aName)
+ : WatchTarget(aName)
+ , mElement(aElement)
+ , mHaveCurrentData(false)
+ , mBlocked(false)
+ , mFinished(false)
+ , mMutex(aName)
+ , mPendingNotifyOutput(false)
{}
void Forget()
{
mElement = nullptr;
NotifyWatchers();
}
// Main thread
MediaDecoderOwner::NextFrameStatus NextFrameStatus()
{
if (!mElement || !mHaveCurrentData || mFinished) {
return MediaDecoderOwner::NEXT_FRAME_UNAVAILABLE;
}
- return mBlocked
- ? MediaDecoderOwner::NEXT_FRAME_UNAVAILABLE_BUFFERING
- : MediaDecoderOwner::NEXT_FRAME_AVAILABLE;
+ return mBlocked ? MediaDecoderOwner::NEXT_FRAME_UNAVAILABLE_BUFFERING
+ : MediaDecoderOwner::NEXT_FRAME_AVAILABLE;
}
void DoNotifyBlocked()
{
mBlocked = true;
NotifyWatchers();
}
void DoNotifyUnblocked()
@@ -4923,17 +5072,18 @@ public:
kungFuDeathGrip->FirstFrameLoaded();
}
NotifyWatchers();
DoNotifyOutput();
}
// These notifications run on the media graph thread so we need to
// dispatch events to the main thread.
- virtual void NotifyBlockingChanged(MediaStreamGraph* aGraph, Blocking aBlocked) override
+ virtual void NotifyBlockingChanged(MediaStreamGraph* aGraph,
+ Blocking aBlocked) override
{
nsCOMPtr<nsIRunnable> event;
if (aBlocked == BLOCKED) {
event = NewRunnableMethod(
"dom::HTMLMediaElement::StreamListener::DoNotifyBlocked",
this,
&StreamListener::DoNotifyBlocked);
} else {
@@ -4942,21 +5092,20 @@ public:
this,
&StreamListener::DoNotifyUnblocked);
}
aGraph->DispatchToMainThreadAfterStreamStateUpdate(event.forget());
}
virtual void NotifyHasCurrentData(MediaStreamGraph* aGraph) override
{
MutexAutoLock lock(mMutex);
- aGraph->DispatchToMainThreadAfterStreamStateUpdate(
- NewRunnableMethod(
- "dom::HTMLMediaElement::StreamListener::DoNotifyHaveCurrentData",
- this,
- &StreamListener::DoNotifyHaveCurrentData));
+ aGraph->DispatchToMainThreadAfterStreamStateUpdate(NewRunnableMethod(
+ "dom::HTMLMediaElement::StreamListener::DoNotifyHaveCurrentData",
+ this,
+ &StreamListener::DoNotifyHaveCurrentData));
}
virtual void NotifyOutput(MediaStreamGraph* aGraph,
GraphTime aCurrentTime) override
{
MutexAutoLock lock(mMutex);
if (mPendingNotifyOutput)
return;
mPendingNotifyOutput = true;
@@ -4973,102 +5122,111 @@ private:
bool mBlocked;
bool mFinished;
// mMutex protects the fields below; they can be accessed on any thread
Mutex mMutex;
bool mPendingNotifyOutput;
};
-class HTMLMediaElement::MediaStreamTracksAvailableCallback:
- public OnTracksAvailableCallback
+class HTMLMediaElement::MediaStreamTracksAvailableCallback
+ : public OnTracksAvailableCallback
{
public:
- explicit MediaStreamTracksAvailableCallback(HTMLMediaElement* aElement):
- OnTracksAvailableCallback(), mElement(aElement)
- {}
+ explicit MediaStreamTracksAvailableCallback(HTMLMediaElement* aElement)
+ : OnTracksAvailableCallback()
+ , mElement(aElement)
+ {}
virtual void NotifyTracksAvailable(DOMMediaStream* aStream)
{
NS_ASSERTION(NS_IsMainThread(), "Should be on main thread.");
mElement->NotifyMediaStreamTracksAvailable(aStream);
}
private:
HTMLMediaElement* mElement;
};
-class HTMLMediaElement::MediaStreamTrackListener :
- public DOMMediaStream::TrackListener
+class HTMLMediaElement::MediaStreamTrackListener
+ : public DOMMediaStream::TrackListener
{
public:
- explicit MediaStreamTrackListener(HTMLMediaElement* aElement):
- mElement(aElement) {}
+ explicit MediaStreamTrackListener(HTMLMediaElement* aElement)
+ : mElement(aElement)
+ {}
void NotifyTrackAdded(const RefPtr<MediaStreamTrack>& aTrack) override
{
mElement->NotifyMediaStreamTrackAdded(aTrack);
}
void NotifyTrackRemoved(const RefPtr<MediaStreamTrack>& aTrack) override
{
mElement->NotifyMediaStreamTrackRemoved(aTrack);
}
void NotifyActive() override
{
- LOG(LogLevel::Debug, ("%p, mSrcStream %p became active",
- mElement, mElement->mSrcStream.get()));
+ LOG(LogLevel::Debug,
+ ("%p, mSrcStream %p became active",
+ mElement,
+ mElement->mSrcStream.get()));
mElement->CheckAutoplayDataReady();
}
void NotifyInactive() override
{
- LOG(LogLevel::Debug, ("%p, mSrcStream %p became inactive",
- mElement, mElement->mSrcStream.get()));
+ LOG(LogLevel::Debug,
+ ("%p, mSrcStream %p became inactive",
+ mElement,
+ mElement->mSrcStream.get()));
MOZ_ASSERT(!mElement->mSrcStream->Active());
if (mElement->mMediaStreamListener) {
mElement->mMediaStreamListener->Forget();
}
mElement->PlaybackEnded();
}
protected:
HTMLMediaElement* const mElement;
};
-void HTMLMediaElement::UpdateSrcMediaStreamPlaying(uint32_t aFlags)
+void
+HTMLMediaElement::UpdateSrcMediaStreamPlaying(uint32_t aFlags)
{
if (!mSrcStream) {
return;
}
// We might be in cycle collection with mSrcStream->GetPlaybackStream() already
// returning null due to unlinking.
MediaStream* stream = GetSrcMediaStream();
bool shouldPlay = !(aFlags & REMOVING_SRC_STREAM) && !mPaused &&
- !mPausedForInactiveDocumentOrChannel && stream;
+ !mPausedForInactiveDocumentOrChannel && stream;
if (shouldPlay == mSrcStreamIsPlaying) {
return;
}
mSrcStreamIsPlaying = shouldPlay;
- LOG(LogLevel::Debug, ("MediaElement %p %s playback of DOMMediaStream %p",
- this, shouldPlay ? "Setting up" : "Removing",
- mSrcStream.get()));
+ LOG(LogLevel::Debug,
+ ("MediaElement %p %s playback of DOMMediaStream %p",
+ this,
+ shouldPlay ? "Setting up" : "Removing",
+ mSrcStream.get()));
if (shouldPlay) {
mSrcStreamPausedCurrentTime = -1;
- mMediaStreamListener = new StreamListener(this,
- "HTMLMediaElement::mMediaStreamListener");
+ mMediaStreamListener =
+ new StreamListener(this, "HTMLMediaElement::mMediaStreamListener");
stream->AddListener(mMediaStreamListener);
mWatchManager.Watch(*mMediaStreamListener,
- &HTMLMediaElement::UpdateReadyStateInternal);
+ &HTMLMediaElement::UpdateReadyStateInternal);
stream->AddAudioOutput(this);
SetVolumeInternal();
VideoFrameContainer* container = GetVideoFrameContainer();
if (mSelectedVideoStreamTrack && container) {
mSelectedVideoStreamTrack->AddVideoOutput(container);
}
@@ -5090,26 +5248,28 @@ void HTMLMediaElement::UpdateSrcMediaStr
}
SetCapturedOutputStreamsEnabled(false); // Mute
}
// If stream is null, then DOMMediaStream::Destroy must have been
// called and that will remove all listeners/outputs.
mWatchManager.Unwatch(*mMediaStreamListener,
- &HTMLMediaElement::UpdateReadyStateInternal);
+ &HTMLMediaElement::UpdateReadyStateInternal);
mMediaStreamListener->Forget();
mMediaStreamListener = nullptr;
}
}
-void HTMLMediaElement::SetupSrcMediaStreamPlayback(DOMMediaStream* aStream)
-{
- NS_ASSERTION(!mSrcStream && !mMediaStreamListener && !mMediaStreamSizeListener,
+void
+HTMLMediaElement::SetupSrcMediaStreamPlayback(DOMMediaStream* aStream)
+{
+ NS_ASSERTION(!mSrcStream && !mMediaStreamListener &&
+ !mMediaStreamSizeListener,
"Should have been ended already");
mSrcStream = aStream;
nsPIDOMWindowInner* window = OwnerDoc()->GetInnerWindow();
if (!window) {
return;
}
@@ -5134,17 +5294,18 @@ void HTMLMediaElement::SetupSrcMediaStre
ChangeNetworkState(nsIDOMHTMLMediaElement::NETWORK_IDLE);
ChangeDelayLoadStatus(false);
CheckAutoplayDataReady();
// FirstFrameLoaded() will be called when the stream has current data.
}
-void HTMLMediaElement::EndSrcMediaStreamPlayback()
+void
+HTMLMediaElement::EndSrcMediaStreamPlayback()
{
MOZ_ASSERT(mSrcStream);
UpdateSrcMediaStreamPlaying(REMOVING_SRC_STREAM);
if (mMediaStreamSizeListener) {
MOZ_ASSERT(mSelectedVideoStreamTrack);
if (mSelectedVideoStreamTrack) {
@@ -5175,49 +5336,51 @@ void HTMLMediaElement::EndSrcMediaStream
static already_AddRefed<AudioTrack>
CreateAudioTrack(AudioStreamTrack* aStreamTrack)
{
nsAutoString id;
nsAutoString label;
aStreamTrack->GetId(id);
aStreamTrack->GetLabel(label);
- return MediaTrackList::CreateAudioTrack(id, NS_LITERAL_STRING("main"),
- label, EmptyString(), true);
+ return MediaTrackList::CreateAudioTrack(
+ id, NS_LITERAL_STRING("main"), label, EmptyString(), true);
}
static already_AddRefed<VideoTrack>
CreateVideoTrack(VideoStreamTrack* aStreamTrack)
{
nsAutoString id;
nsAutoString label;
aStreamTrack->GetId(id);
aStreamTrack->GetLabel(label);
- return MediaTrackList::CreateVideoTrack(id, NS_LITERAL_STRING("main"),
- label, EmptyString(),
- aStreamTrack);
-}
-
-void
-HTMLMediaElement::NotifyMediaStreamTrackAdded(const RefPtr<MediaStreamTrack>& aTrack)
+ return MediaTrackList::CreateVideoTrack(
+ id, NS_LITERAL_STRING("main"), label, EmptyString(), aStreamTrack);
+}
+
+void
+HTMLMediaElement::NotifyMediaStreamTrackAdded(
+ const RefPtr<MediaStreamTrack>& aTrack)
{
MOZ_ASSERT(aTrack);
if (aTrack->Ended()) {
return;
}
#ifdef DEBUG
nsString id;
aTrack->GetId(id);
- LOG(LogLevel::Debug, ("%p, Adding %sTrack with id %s",
- this, aTrack->AsAudioStreamTrack() ? "Audio" : "Video",
- NS_ConvertUTF16toUTF8(id).get()));
+ LOG(LogLevel::Debug,
+ ("%p, Adding %sTrack with id %s",
+ this,
+ aTrack->AsAudioStreamTrack() ? "Audio" : "Video",
+ NS_ConvertUTF16toUTF8(id).get()));
#endif
if (AudioStreamTrack* t = aTrack->AsAudioStreamTrack()) {
RefPtr<AudioTrack> audioTrack = CreateAudioTrack(t);
AudioTracks()->AddTrack(audioTrack);
} else if (VideoStreamTrack* t = aTrack->AsVideoStreamTrack()) {
// TODO: Fix this per the spec on bug 1273443.
if (!IsVideo()) {
@@ -5232,42 +5395,45 @@ HTMLMediaElement::NotifyMediaStreamTrack
videoTrack->SetEnabledInternal(true, MediaTrack::FIRE_NO_EVENTS);
}
}
mWatchManager.ManualNotify(&HTMLMediaElement::UpdateReadyStateInternal);
}
void
-HTMLMediaElement::NotifyMediaStreamTrackRemoved(const RefPtr<MediaStreamTrack>& aTrack)
+HTMLMediaElement::NotifyMediaStreamTrackRemoved(
+ const RefPtr<MediaStreamTrack>& aTrack)
{
MOZ_ASSERT(aTrack);
nsAutoString id;
aTrack->GetId(id);
- LOG(LogLevel::Debug, ("%p, Removing %sTrack with id %s",
- this, aTrack->AsAudioStreamTrack() ? "Audio" : "Video",
- NS_ConvertUTF16toUTF8(id).get()));
+ LOG(LogLevel::Debug,
+ ("%p, Removing %sTrack with id %s",
+ this,
+ aTrack->AsAudioStreamTrack() ? "Audio" : "Video",
+ NS_ConvertUTF16toUTF8(id).get()));
if (MediaTrack* t = AudioTracks()->GetTrackById(id)) {
AudioTracks()->RemoveTrack(t);
} else if (MediaTrack* t = VideoTracks()->GetTrackById(id)) {
VideoTracks()->RemoveTrack(t);
} else {
NS_ASSERTION(aTrack->AsVideoStreamTrack() && !IsVideo(),
"MediaStreamTrack ended but did not exist in track lists. "
"This is only allowed if a video element ends and we are an "
"audio element.");
return;
}
}
-
-void HTMLMediaElement::ProcessMediaFragmentURI()
+void
+HTMLMediaElement::ProcessMediaFragmentURI()
{
nsMediaFragmentURIParser parser(mLoadingSrc);
if (mDecoder && parser.HasEndTime()) {
mFragmentEnd = parser.GetEndTime();
}
if (parser.HasStartTime()) {
@@ -5279,39 +5445,41 @@ void HTMLMediaElement::ProcessMediaFragm
void
HTMLMediaElement::MetadataLoaded(const MediaInfo* aInfo,
UniquePtr<const MetadataTags> aTags)
{
MOZ_ASSERT(NS_IsMainThread());
SetMediaInfo(*aInfo);
- mIsEncrypted = aInfo->IsEncrypted() || mPendingEncryptedInitData.IsEncrypted();
+ mIsEncrypted =
+ aInfo->IsEncrypted() || mPendingEncryptedInitData.IsEncrypted();
mTags = Move(aTags);
mLoadedDataFired = false;
ChangeReadyState(nsIDOMHTMLMediaElement::HAVE_METADATA);
DispatchAsyncEvent(NS_LITERAL_STRING("durationchange"));
if (IsVideo() && HasVideo()) {
DispatchAsyncEvent(NS_LITERAL_STRING("resize"));
}
- NS_ASSERTION(!HasVideo() ||
- (mMediaInfo.mVideo.mDisplay.width > 0 &&
- mMediaInfo.mVideo.mDisplay.height > 0),
+ NS_ASSERTION(!HasVideo() || (mMediaInfo.mVideo.mDisplay.width > 0 &&
+ mMediaInfo.mVideo.mDisplay.height > 0),
"Video resolution must be known on 'loadedmetadata'");
DispatchAsyncEvent(NS_LITERAL_STRING("loadedmetadata"));
- if (mDecoder && mDecoder->IsTransportSeekable() && mDecoder->IsMediaSeekable()) {
+ if (mDecoder && mDecoder->IsTransportSeekable() &&
+ mDecoder->IsMediaSeekable()) {
ProcessMediaFragmentURI();
mDecoder->SetFragmentEndTime(mFragmentEnd);
}
if (mIsEncrypted) {
// We only support playback of encrypted content via MSE by default.
if (!mMediaSource && Preferences::GetBool("media.eme.mse-only", true)) {
- DecodeError(MediaResult(NS_ERROR_DOM_MEDIA_FATAL_ERR,
- "Encrypted content not supported outside of MSE"));
+ DecodeError(
+ MediaResult(NS_ERROR_DOM_MEDIA_FATAL_ERR,
+ "Encrypted content not supported outside of MSE"));
return;
}
// Dispatch a distinct 'encrypted' event for each initData we have.
for (const auto& initData : mPendingEncryptedInitData.mInitDatas) {
DispatchEncrypted(initData.mInitData, initData.mType);
}
mPendingEncryptedInitData.Reset();
@@ -5347,20 +5515,24 @@ HTMLMediaElement::MetadataLoaded(const M
if (t->Selected()) {
AddCaptureMediaTrackToOutputStream(t, ms);
}
}
}
}
}
-void HTMLMediaElement::FirstFrameLoaded()
-{
- LOG(LogLevel::Debug, ("%p, FirstFrameLoaded() mFirstFrameLoaded=%d mWaitingForKey=%d",
- this, mFirstFrameLoaded, mWaitingForKey));
+void
+HTMLMediaElement::FirstFrameLoaded()
+{
+ LOG(LogLevel::Debug,
+ ("%p, FirstFrameLoaded() mFirstFrameLoaded=%d mWaitingForKey=%d",
+ this,
+ mFirstFrameLoaded,
+ mWaitingForKey));
NS_ASSERTION(!mSuspendedAfterFirstFrame, "Should not have already suspended");
if (!mFirstFrameLoaded) {
mFirstFrameLoaded = true;
UpdateReadyStateInternal();
}
@@ -5369,26 +5541,28 @@ void HTMLMediaElement::FirstFrameLoaded(
if (mDecoder && mAllowSuspendAfterFirstFrame && mPaused &&
!HasAttr(kNameSpaceID_None, nsGkAtoms::autoplay) &&
mPreloadAction == HTMLMediaElement::PRELOAD_METADATA) {
mSuspendedAfterFirstFrame = true;
mDecoder->Suspend();
}
}
-void HTMLMediaElement::NetworkError()
+void
+HTMLMediaElement::NetworkError()
{
if (mReadyState == nsIDOMHTMLMediaElement::HAVE_NOTHING) {
NoSupportedMediaSourceError();
} else {
Error(MEDIA_ERR_NETWORK);
}
}
-void HTMLMediaElement::DecodeError(const MediaResult& aError)
+void
+HTMLMediaElement::DecodeError(const MediaResult& aError)
{
nsAutoString src;
GetCurrentSrc(src);
const char16_t* params[] = { src.get() };
ReportLoadError("MediaLoadDecodeError", params, ArrayLength(params));
DecoderDoctorDiagnostics diagnostics;
diagnostics.StoreDecodeError(OwnerDoc(), aError, src, __func__);
@@ -5405,61 +5579,67 @@ void HTMLMediaElement::DecodeError(const
}
} else if (mReadyState == nsIDOMHTMLMediaElement::HAVE_NOTHING) {
NoSupportedMediaSourceError(aError.Description());
} else {
Error(MEDIA_ERR_DECODE, aError.Description());
}
}
-void HTMLMediaElement::DecodeWarning(const MediaResult& aError)
+void
+HTMLMediaElement::DecodeWarning(const MediaResult& aError)
{
nsAutoString src;
GetCurrentSrc(src);
DecoderDoctorDiagnostics diagnostics;
diagnostics.StoreDecodeWarning(OwnerDoc(), aError, src, __func__);
}
-bool HTMLMediaElement::HasError() const
+bool
+HTMLMediaElement::HasError() const
{
return GetError();
}
-void HTMLMediaElement::LoadAborted()
+void
+HTMLMediaElement::LoadAborted()
{
Error(MEDIA_ERR_ABORTED);
}
-void HTMLMediaElement::Error(uint16_t aErrorCode,
- const nsACString& aErrorDetails)
+void
+HTMLMediaElement::Error(uint16_t aErrorCode, const nsACString& aErrorDetails)
{
mErrorSink->SetError(aErrorCode, aErrorDetails);
ChangeDelayLoadStatus(false);
UpdateAudioChannelPlayingState();
}
-void HTMLMediaElement::PlaybackEnded()
+void
+HTMLMediaElement::PlaybackEnded()
{
// We changed state which can affect AddRemoveSelfReference
AddRemoveSelfReference();
NS_ASSERTION(!mDecoder || mDecoder->IsEnded(),
"Decoder fired ended, but not in ended state");
// Discard all output streams that have finished now.
for (int32_t i = mOutputStreams.Length() - 1; i >= 0; --i) {
if (mOutputStreams[i].mFinishWhenEnded) {
- LOG(LogLevel::Debug, ("Playback ended. Removing output stream %p",
- mOutputStreams[i].mStream.get()));
+ LOG(LogLevel::Debug,
+ ("Playback ended. Removing output stream %p",
+ mOutputStreams[i].mStream.get()));
mOutputStreams.RemoveElementAt(i);
}
}
if (mSrcStream) {
- LOG(LogLevel::Debug, ("%p, got duration by reaching the end of the resource", this));
+ LOG(LogLevel::Debug,
+ ("%p, got duration by reaching the end of the resource", this));
DispatchAsyncEvent(NS_LITERAL_STRING("durationchange"));
}
if (HasAttr(kNameSpaceID_None, nsGkAtoms::loop)) {
SetCurrentTime(0);
return;
}
@@ -5474,22 +5654,24 @@ void HTMLMediaElement::PlaybackEnded()
// A MediaStream that goes from inactive to active shall be eligible for
// autoplay again according to the mediacapture-main spec.
mAutoplaying = true;
}
DispatchAsyncEvent(NS_LITERAL_STRING("ended"));
}
-void HTMLMediaElement::SeekStarted()
+void
+HTMLMediaElement::SeekStarted()
{
DispatchAsyncEvent(NS_LITERAL_STRING("seeking"));
}
-void HTMLMediaElement::SeekCompleted()
+void
+HTMLMediaElement::SeekCompleted()
{
mPlayingBeforeSeek = false;
SetPlayedOrSeeked(true);
if (mTextTrackManager) {
mTextTrackManager->DidSeek();
}
FireTimeUpdate(false);
DispatchAsyncEvent(NS_LITERAL_STRING("seeked"));
@@ -5501,53 +5683,57 @@ void HTMLMediaElement::SeekCompleted()
}
void
HTMLMediaElement::NotifySuspendedByCache(bool aSuspendedByCache)
{
mDownloadSuspendedByCache = aSuspendedByCache;
}
-void HTMLMediaElement::DownloadSuspended()
+void
+HTMLMediaElement::DownloadSuspended()
{
if (mNetworkState == nsIDOMHTMLMediaElement::NETWORK_LOADING) {
DispatchAsyncEvent(NS_LITERAL_STRING("progress"));
}
if (mBegun) {
ChangeNetworkState(nsIDOMHTMLMediaElement::NETWORK_IDLE);
}
}
-void HTMLMediaElement::DownloadResumed(bool aForceNetworkLoading)
+void
+HTMLMediaElement::DownloadResumed(bool aForceNetworkLoading)
{
if (mBegun || aForceNetworkLoading) {
ChangeNetworkState(nsIDOMHTMLMediaElement::NETWORK_LOADING);
}
}
-void HTMLMediaElement::CheckProgress(bool aHaveNewProgress)
+void
+HTMLMediaElement::CheckProgress(bool aHaveNewProgress)
{
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(mNetworkState == nsIDOMHTMLMediaElement::NETWORK_LOADING);
TimeStamp now = TimeStamp::NowLoRes();
if (aHaveNewProgress) {
mDataTime = now;
}
// If this is the first progress, or PROGRESS_MS has passed since the last
// progress event fired and more data has arrived since then, fire a
// progress event.
NS_ASSERTION((mProgressTime.IsNull() && !aHaveNewProgress) ||
- !mDataTime.IsNull(),
+ !mDataTime.IsNull(),
"null TimeStamp mDataTime should not be used in comparison");
- if (mProgressTime.IsNull() ? aHaveNewProgress
- : (now - mProgressTime >= TimeDuration::FromMilliseconds(PROGRESS_MS) &&
- mDataTime > mProgressTime)) {
+ if (mProgressTime.IsNull()
+ ? aHaveNewProgress
+ : (now - mProgressTime >= TimeDuration::FromMilliseconds(PROGRESS_MS) &&
+ mDataTime > mProgressTime)) {
DispatchAsyncEvent(NS_LITERAL_STRING("progress"));
// Resolution() ensures that future data will have now > mProgressTime,
// and so will trigger another event. mDataTime is not reset because it
// is still required to detect stalled; it is similarly offset by
// resolution to indicate the new data has not yet arrived.
mProgressTime = now - TimeDuration::Resolution();
if (mDataTime > mProgressTime) {
mDataTime = mProgressTime;
@@ -5577,122 +5763,146 @@ void HTMLMediaElement::CheckProgress(boo
// is more progress.
StopProgress();
}
AddRemoveSelfReference();
}
/* static */
-void HTMLMediaElement::ProgressTimerCallback(nsITimer* aTimer, void* aClosure)
+void
+HTMLMediaElement::ProgressTimerCallback(nsITimer* aTimer, void* aClosure)
{
auto decoder = static_cast<HTMLMediaElement*>(aClosure);
decoder->CheckProgress(false);
}
-void HTMLMediaElement::StartProgressTimer()
+void
+HTMLMediaElement::StartProgressTimer()
{
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(mNetworkState == nsIDOMHTMLMediaElement::NETWORK_LOADING);
NS_ASSERTION(!mProgressTimer, "Already started progress timer.");
mProgressTimer = do_CreateInstance("@mozilla.org/timer;1");
mProgressTimer->SetTarget(mMainThreadEventTarget);
mProgressTimer->InitWithNamedFuncCallback(
- ProgressTimerCallback, this, PROGRESS_MS, nsITimer::TYPE_REPEATING_SLACK,
+ ProgressTimerCallback,
+ this,
+ PROGRESS_MS,
+ nsITimer::TYPE_REPEATING_SLACK,
"HTMLMediaElement::ProgressTimerCallback");
}
-void HTMLMediaElement::StartProgress()
+void
+HTMLMediaElement::StartProgress()
{
// Record the time now for detecting stalled.
mDataTime = TimeStamp::NowLoRes();
// Reset mProgressTime so that mDataTime is not indicating bytes received
// after the last progress event.
mProgressTime = TimeStamp();
StartProgressTimer();
}
-void HTMLMediaElement::StopProgress()
+void
+HTMLMediaElement::StopProgress()
{
MOZ_ASSERT(NS_IsMainThread());
if (!mProgressTimer) {
return;
}
mProgressTimer->Cancel();
mProgressTimer = nullptr;
}
-void HTMLMediaElement::DownloadProgressed()
+void
+HTMLMediaElement::DownloadProgressed()
{
if (mNetworkState != nsIDOMHTMLMediaElement::NETWORK_LOADING) {
return;
}
CheckProgress(true);
}
-bool HTMLMediaElement::ShouldCheckAllowOrigin()
+bool
+HTMLMediaElement::ShouldCheckAllowOrigin()
{
return mCORSMode != CORS_NONE;
}
-bool HTMLMediaElement::IsCORSSameOrigin()
+bool
+HTMLMediaElement::IsCORSSameOrigin()
{
bool subsumes;
RefPtr<nsIPrincipal> principal = GetCurrentPrincipal();
- return
- (NS_SUCCEEDED(NodePrincipal()->Subsumes(principal, &subsumes)) && subsumes) ||
- ShouldCheckAllowOrigin();
+ return (NS_SUCCEEDED(NodePrincipal()->Subsumes(principal, &subsumes)) &&
+ subsumes) ||
+ ShouldCheckAllowOrigin();
}
void
HTMLMediaElement::UpdateReadyStateInternal()
{
if (!mDecoder && !mSrcStream) {
// Not initialized - bail out.
- LOG(LogLevel::Debug, ("MediaElement %p UpdateReadyStateInternal() "
- "Not initialized", this));
+ LOG(LogLevel::Debug,
+ ("MediaElement %p UpdateReadyStateInternal() "
+ "Not initialized",
+ this));
return;
}
if (mDecoder && mReadyState < nsIDOMHTMLMediaElement::HAVE_METADATA) {
// aNextFrame might have a next frame because the decoder can advance
// on its own thread before MetadataLoaded gets a chance to run.
// The arrival of more data can't change us out of this readyState.
- LOG(LogLevel::Debug, ("MediaElement %p UpdateReadyStateInternal() "
- "Decoder ready state < HAVE_METADATA", this));
+ LOG(LogLevel::Debug,
+ ("MediaElement %p UpdateReadyStateInternal() "
+ "Decoder ready state < HAVE_METADATA",
+ this));
return;
}
if (mSrcStream && mReadyState < nsIDOMHTMLMediaElement::HAVE_METADATA) {
if (!mSrcStreamTracksAvailable) {
- LOG(LogLevel::Debug, ("MediaElement %p UpdateReadyStateInternal() "
- "MediaStreamTracks not available yet", this));
+ LOG(LogLevel::Debug,
+ ("MediaElement %p UpdateReadyStateInternal() "
+ "MediaStreamTracks not available yet",
+ this));
return;
}
bool hasAudioTracks = !AudioTracks()->IsEmpty();
bool hasVideoTracks = !VideoTracks()->IsEmpty();
if (!hasAudioTracks && !hasVideoTracks) {
- LOG(LogLevel::Debug, ("MediaElement %p UpdateReadyStateInternal() "
- "Stream with no tracks", this));
+ LOG(LogLevel::Debug,
+ ("MediaElement %p UpdateReadyStateInternal() "
+ "Stream with no tracks",
+ this));
return;
}
if (IsVideo() && hasVideoTracks && !HasVideo()) {
- LOG(LogLevel::Debug, ("MediaElement %p UpdateReadyStateInternal() "
- "Stream waiting for video", this));
+ LOG(LogLevel::Debug,
+ ("MediaElement %p UpdateReadyStateInternal() "
+ "Stream waiting for video",
+ this));
return;
}
- LOG(LogLevel::Debug, ("MediaElement %p UpdateReadyStateInternal() Stream has "
- "metadata; audioTracks=%d, videoTracks=%d, "
- "hasVideoFrame=%d", this, AudioTracks()->Length(),
- VideoTracks()->Length(), HasVideo()));
+ LOG(LogLevel::Debug,
+ ("MediaElement %p UpdateReadyStateInternal() Stream has "
+ "metadata; audioTracks=%d, videoTracks=%d, "
+ "hasVideoFrame=%d",
+ this,
+ AudioTracks()->Length(),
+ VideoTracks()->Length(),
+ HasVideo()));
// We are playing a stream that has video and a video frame is now set.
// This means we have all metadata needed to change ready state.
MediaInfo mediaInfo = mMediaInfo;
if (hasAudioTracks) {
mediaInfo.EnableAudio();
}
if (hasVideoTracks) {
@@ -5735,30 +5945,34 @@ HTMLMediaElement::UpdateReadyStateIntern
if (nextFrameStatus == NEXT_FRAME_AVAILABLE) {
// We have new frames after dispatching "waitingforkey".
// This means we've got the key and can reset mWaitingForKey now.
mWaitingForKey = NOT_WAITING_FOR_KEY;
}
}
if (nextFrameStatus == MediaDecoderOwner::NEXT_FRAME_UNAVAILABLE_SEEKING) {
- LOG(LogLevel::Debug, ("MediaElement %p UpdateReadyStateInternal() "
- "NEXT_FRAME_UNAVAILABLE_SEEKING; Forcing HAVE_METADATA", this));
+ LOG(LogLevel::Debug,
+ ("MediaElement %p UpdateReadyStateInternal() "
+ "NEXT_FRAME_UNAVAILABLE_SEEKING; Forcing HAVE_METADATA",
+ this));
ChangeReadyState(nsIDOMHTMLMediaElement::HAVE_METADATA);
return;
}
- if (IsVideo() && HasVideo() && !IsPlaybackEnded() &&
- GetImageContainer() && !GetImageContainer()->HasCurrentImage()) {
+ if (IsVideo() && HasVideo() && !IsPlaybackEnded() && GetImageContainer() &&
+ !GetImageContainer()->HasCurrentImage()) {
// Don't advance if we are playing video, but don't have a video frame.
// Also, if video became available after advancing to HAVE_CURRENT_DATA
// while we are still playing, we need to revert to HAVE_METADATA until
// a video frame is available.
- LOG(LogLevel::Debug, ("MediaElement %p UpdateReadyStateInternal() "
- "Playing video but no video frame; Forcing HAVE_METADATA", this));
+ LOG(LogLevel::Debug,
+ ("MediaElement %p UpdateReadyStateInternal() "
+ "Playing video but no video frame; Forcing HAVE_METADATA",
+ this));
ChangeReadyState(nsIDOMHTMLMediaElement::HAVE_METADATA);
return;
}
if (!mFirstFrameLoaded) {
// We haven't yet loaded the first frame, making us unable to determine
// if we have enough valid data at the present stage.
return;
@@ -5783,74 +5997,84 @@ HTMLMediaElement::UpdateReadyStateIntern
// media cache. So move readyState into HAVE_ENOUGH_DATA, in case there's
// script waiting for a "canplaythrough" event; without this forced
// transition, we will never fire the "canplaythrough" event if the
// media cache is too small, and scripts are bound to fail. Don't force
// this transition if the decoder is in ended state; the readyState
// should remain at HAVE_CURRENT_DATA in this case.
// Note that this state transition includes the case where we finished
// downloaded the whole data stream.
- LOG(LogLevel::Debug, ("MediaElement %p UpdateReadyStateInternal() "
- "Decoder download suspended by cache", this));
+ LOG(LogLevel::Debug,
+ ("MediaElement %p UpdateReadyStateInternal() "
+ "Decoder download suspended by cache",
+ this));
ChangeReadyState(nsIDOMHTMLMediaElement::HAVE_ENOUGH_DATA);
return;
}
if (nextFrameStatus != MediaDecoderOwner::NEXT_FRAME_AVAILABLE) {
- LOG(LogLevel::Debug, ("MediaElement %p UpdateReadyStateInternal() "
- "Next frame not available", this));
+ LOG(LogLevel::Debug,
+ ("MediaElement %p UpdateReadyStateInternal() "
+ "Next frame not available",
+ this));
ChangeReadyState(nsIDOMHTMLMediaElement::HAVE_CURRENT_DATA);
return;
}
if (mSrcStream) {
- LOG(LogLevel::Debug, ("MediaElement %p UpdateReadyStateInternal() "
- "Stream HAVE_ENOUGH_DATA", this));
+ LOG(LogLevel::Debug,
+ ("MediaElement %p UpdateReadyStateInternal() "
+ "Stream HAVE_ENOUGH_DATA",
+ this));
ChangeReadyState(nsIDOMHTMLMediaElement::HAVE_ENOUGH_DATA);
return;
}
// Now see if we should set HAVE_ENOUGH_DATA.
// If it's something we don't know the size of, then we can't
// make a real estimate, so we go straight to HAVE_ENOUGH_DATA once
// we've downloaded enough data that our download rate is considered
// reliable. We have to move to HAVE_ENOUGH_DATA at some point or
// autoplay elements for live streams will never play. Otherwise we
// move to HAVE_ENOUGH_DATA if we can play through the entire media
// without stopping to buffer.
if (mDecoder->CanPlayThrough()) {
- LOG(LogLevel::Debug, ("MediaElement %p UpdateReadyStateInternal() "
- "Decoder can play through", this));
+ LOG(LogLevel::Debug,
+ ("MediaElement %p UpdateReadyStateInternal() "
+ "Decoder can play through",
+ this));
ChangeReadyState(nsIDOMHTMLMediaElement::HAVE_ENOUGH_DATA);
return;
}
- LOG(LogLevel::Debug, ("MediaElement %p UpdateReadyStateInternal() "
- "Default; Decoder has future data", this));
+ LOG(LogLevel::Debug,
+ ("MediaElement %p UpdateReadyStateInternal() "
+ "Default; Decoder has future data",
+ this));
ChangeReadyState(nsIDOMHTMLMediaElement::HAVE_FUTURE_DATA);
}
-static const char* const gReadyStateToString[] = {
- "HAVE_NOTHING",
- "HAVE_METADATA",
- "HAVE_CURRENT_DATA",
- "HAVE_FUTURE_DATA",
- "HAVE_ENOUGH_DATA"
-};
-
-void HTMLMediaElement::ChangeReadyState(nsMediaReadyState aState)
+static const char* const gReadyStateToString[] = { "HAVE_NOTHING",
+ "HAVE_METADATA",
+ "HAVE_CURRENT_DATA",
+ "HAVE_FUTURE_DATA",
+ "HAVE_ENOUGH_DATA" };
+
+void
+HTMLMediaElement::ChangeReadyState(nsMediaReadyState aState)
{
nsMediaReadyState oldState = mReadyState;
mReadyState = aState;
if (mNetworkState == nsIDOMHTMLMediaElement::NETWORK_EMPTY ||
oldState == mReadyState) {
return;
}
- LOG(LogLevel::Debug, ("%p Ready state changed to %s", this, gReadyStateToString[aState]));
+ LOG(LogLevel::Debug,
+ ("%p Ready state changed to %s", this, gReadyStateToString[aState]));
UpdateAudioChannelPlayingState();
// Handle raising of "waiting" event during seek (see 4.8.10.9)
// or
// 4.8.12.7 Ready states:
// "If the previous ready state was HAVE_FUTURE_DATA or more, and the new
// ready state is HAVE_CURRENT_DATA or less
@@ -5888,32 +6112,32 @@ void HTMLMediaElement::ChangeReadyState(
CheckAutoplayDataReady();
if (oldState < nsIDOMHTMLMediaElement::HAVE_ENOUGH_DATA &&
mReadyState >= nsIDOMHTMLMediaElement::HAVE_ENOUGH_DATA) {
DispatchAsyncEvent(NS_LITERAL_STRING("canplaythrough"));
}
}
-static const char* const gNetworkStateToString[] = {
- "EMPTY",
- "IDLE",
- "LOADING",
- "NO_SOURCE"
- };
-
-void HTMLMediaElement::ChangeNetworkState(nsMediaNetworkState aState)
+static const char* const gNetworkStateToString[] = { "EMPTY",
+ "IDLE",
+ "LOADING",
+ "NO_SOURCE" };
+
+void
+HTMLMediaElement::ChangeNetworkState(nsMediaNetworkState aState)
{
if (mNetworkState == aState) {
return;
}
nsMediaNetworkState oldState = mNetworkState;
mNetworkState = aState;
- LOG(LogLevel::Debug, ("%p Network state changed to %s", this, gNetworkStateToString[aState]));
+ LOG(LogLevel::Debug,
+ ("%p Network state changed to %s", this, gNetworkStateToString[aState]));
// TODO: |mBegun| reflects the download status. We should be able to remove
// it and check |mNetworkState| only.
if (oldState == nsIDOMHTMLMediaElement::NETWORK_LOADING) {
// Reset |mBegun| since we're not downloading anymore.
mBegun = false;
// Stop progress notification when exiting NETWORK_LOADING.
@@ -5930,17 +6154,18 @@ void HTMLMediaElement::ChangeNetworkStat
// Fire 'suspend' event when entering NETWORK_IDLE and no error presented.
DispatchAsyncEvent(NS_LITERAL_STRING("suspend"));
}
// Changing mNetworkState affects AddRemoveSelfReference().
AddRemoveSelfReference();
}
-bool HTMLMediaElement::CanActivateAutoplay()
+bool
+HTMLMediaElement::CanActivateAutoplay()
{
// For stream inputs, we activate autoplay on HAVE_NOTHING because
// this element itself might be blocking the stream from making progress by
// being paused. We only check that it has data by checking its active state.
// We also activate autoplay when playing a media source since the data
// download is controlled by the script and there is no way to evaluate
// MediaDecoder::CanPlayThrough().
@@ -5961,31 +6186,34 @@ bool HTMLMediaElement::CanActivateAutopl
}
if (mPausedForInactiveDocumentOrChannel) {
return false;
}
if (mAudioChannelWrapper) {
// Note: SUSPENDED_PAUSE and SUSPENDED_BLOCK will be merged into one single state.
- if (mAudioChannelWrapper->GetSuspendType() == nsISuspendedTypes::SUSPENDED_PAUSE ||
- mAudioChannelWrapper->GetSuspendType() == nsISuspendedTypes::SUSPENDED_BLOCK ||
+ if (mAudioChannelWrapper->GetSuspendType() ==
+ nsISuspendedTypes::SUSPENDED_PAUSE ||
+ mAudioChannelWrapper->GetSuspendType() ==
+ nsISuspendedTypes::SUSPENDED_BLOCK ||
mAudioChannelWrapper->IsPlaybackBlocked()) {
return false;
}
}
bool hasData =
(mDecoder && mReadyState >= nsIDOMHTMLMediaElement::HAVE_ENOUGH_DATA) ||
(mSrcStream && mSrcStream->Active());
return hasData;
}
-void HTMLMediaElement::CheckAutoplayDataReady()
+void
+HTMLMediaElement::CheckAutoplayDataReady()
{
if (!CanActivateAutoplay()) {
return;
}
mPaused = false;
// We changed mPaused which can affect AddRemoveSelfReference
AddRemoveSelfReference();
@@ -6003,131 +6231,143 @@ void HTMLMediaElement::CheckAutoplayData
}
// For blocked media, the event would be pending until it is resumed.
DispatchAsyncEvent(NS_LITERAL_STRING("play"));
DispatchAsyncEvent(NS_LITERAL_STRING("playing"));
}
-bool HTMLMediaElement::IsActive() const
+bool
+HTMLMediaElement::IsActive() const
{
nsIDocument* ownerDoc = OwnerDoc();
return ownerDoc && ownerDoc->IsActive() && ownerDoc->IsVisible();
}
-bool HTMLMediaElement::IsHidden() const
+bool
+HTMLMediaElement::IsHidden() const
{
nsIDocument* ownerDoc;
return mUnboundFromTree || !(ownerDoc = OwnerDoc()) || ownerDoc->Hidden();
}
-VideoFrameContainer* HTMLMediaElement::GetVideoFrameContainer()
+VideoFrameContainer*
+HTMLMediaElement::GetVideoFrameContainer()
{
if (mShuttingDown) {
return nullptr;
}
if (mVideoFrameContainer)
return mVideoFrameContainer;
// Only video frames need an image container.
if (!IsVideo()) {
return nullptr;
}
- mVideoFrameContainer =
- new VideoFrameContainer(this, LayerManager::CreateImageContainer(ImageContainer::ASYNCHRONOUS));
+ mVideoFrameContainer = new VideoFrameContainer(
+ this, LayerManager::CreateImageContainer(ImageContainer::ASYNCHRONOUS));
return mVideoFrameContainer;
}
void
HTMLMediaElement::PrincipalChanged(DOMMediaStream* aStream)
{
LOG(LogLevel::Info, ("HTMLMediaElement %p Stream principal changed.", this));
nsContentUtils::CombineResourcePrincipals(&mSrcStreamVideoPrincipal,
aStream->GetVideoPrincipal());
- LOG(LogLevel::Debug, ("HTMLMediaElement %p Stream video principal changed to "
- "%p. Waiting for it to reach VideoFrameContainer before "
- "setting.", this, aStream->GetVideoPrincipal()));
+ LOG(LogLevel::Debug,
+ ("HTMLMediaElement %p Stream video principal changed to "
+ "%p. Waiting for it to reach VideoFrameContainer before "
+ "setting.",
+ this,
+ aStream->GetVideoPrincipal()));
if (mVideoFrameContainer) {
- UpdateSrcStreamVideoPrincipal(mVideoFrameContainer->GetLastPrincipalHandle());
- }
-}
-
-void
-HTMLMediaElement::UpdateSrcStreamVideoPrincipal(const PrincipalHandle& aPrincipalHandle)
+ UpdateSrcStreamVideoPrincipal(
+ mVideoFrameContainer->GetLastPrincipalHandle());
+ }
+}
+
+void
+HTMLMediaElement::UpdateSrcStreamVideoPrincipal(
+ const PrincipalHandle& aPrincipalHandle)
{
nsTArray<RefPtr<VideoStreamTrack>> videoTracks;
mSrcStream->GetVideoTracks(videoTracks);
PrincipalHandle handle(aPrincipalHandle);
bool matchesTrackPrincipal = false;
for (const RefPtr<VideoStreamTrack>& track : videoTracks) {
- if (PrincipalHandleMatches(handle,
- track->GetPrincipal()) &&
+ if (PrincipalHandleMatches(handle, track->GetPrincipal()) &&
!track->Ended()) {
// When the PrincipalHandle for the VideoFrameContainer changes to that of
// a track in mSrcStream we know that a removed track was displayed but
// is no longer so.
matchesTrackPrincipal = true;
- LOG(LogLevel::Debug, ("HTMLMediaElement %p VideoFrameContainer's "
- "PrincipalHandle matches track %p. That's all we "
- "need.", this, track.get()));
+ LOG(LogLevel::Debug,
+ ("HTMLMediaElement %p VideoFrameContainer's "
+ "PrincipalHandle matches track %p. That's all we "
+ "need.",
+ this,
+ track.get()));
break;
}
}
if (matchesTrackPrincipal) {
mSrcStreamVideoPrincipal = mSrcStream->GetVideoPrincipal();
}
}
void
-HTMLMediaElement::PrincipalHandleChangedForVideoFrameContainer(VideoFrameContainer* aContainer,
- const PrincipalHandle& aNewPrincipalHandle)
+HTMLMediaElement::PrincipalHandleChangedForVideoFrameContainer(
+ VideoFrameContainer* aContainer,
+ const PrincipalHandle& aNewPrincipalHandle)
{
MOZ_ASSERT(NS_IsMainThread());
if (!mSrcStream) {
return;
}
- LOG(LogLevel::Debug, ("HTMLMediaElement %p PrincipalHandle changed in "
- "VideoFrameContainer.",
- this));
+ LOG(LogLevel::Debug,
+ ("HTMLMediaElement %p PrincipalHandle changed in "
+ "VideoFrameContainer.",
+ this));
UpdateSrcStreamVideoPrincipal(aNewPrincipalHandle);
}
-nsresult HTMLMediaElement::DispatchEvent(const nsAString& aName)
-{
- LOG_EVENT(LogLevel::Debug, ("%p Dispatching event %s", this,
- NS_ConvertUTF16toUTF8(aName).get()));
+nsresult
+HTMLMediaElement::DispatchEvent(const nsAString& aName)
+{
+ LOG_EVENT(
+ LogLevel::Debug,
+ ("%p Dispatching event %s", this, NS_ConvertUTF16toUTF8(aName).get()));
// Save events that occur while in the bfcache. These will be dispatched
// if the page comes out of the bfcache.
if (mEventDeliveryPaused) {
mPendingEvents.AppendElement(aName);
return NS_OK;
}
- return nsContentUtils::DispatchTrustedEvent(OwnerDoc(),
- static_cast<nsIContent*>(this),
- aName,
- false,
- false);
-}
-
-nsresult HTMLMediaElement::DispatchAsyncEvent(const nsAString& aName)
-{
- LOG_EVENT(LogLevel::Debug, ("%p Queuing event %s", this,
- NS_ConvertUTF16toUTF8(aName).get()));
+ return nsContentUtils::DispatchTrustedEvent(
+ OwnerDoc(), static_cast<nsIContent*>(this), aName, false, false);
+}
+
+nsresult
+HTMLMediaElement::DispatchAsyncEvent(const nsAString& aName)
+{
+ LOG_EVENT(LogLevel::Debug,
+ ("%p Queuing event %s", this, NS_ConvertUTF16toUTF8(aName).get()));
// Save events that occur while in the bfcache. These will be dispatched
// if the page comes out of the bfcache.
if (mEventDeliveryPaused) {
mPendingEvents.AppendElement(aName);
return NS_OK;
}
@@ -6152,109 +6392,120 @@ nsresult HTMLMediaElement::DispatchAsync
} else if (aName.EqualsLiteral("pause")) {
mPlayTime.Pause();
HiddenVideoStop();
}
return NS_OK;
}
-nsresult HTMLMediaElement::DispatchPendingMediaEvents()
+nsresult
+HTMLMediaElement::DispatchPendingMediaEvents()
{
NS_ASSERTION(!mEventDeliveryPaused,
"Must not be in bfcache when dispatching pending media events");
uint32_t count = mPendingEvents.Length();
for (uint32_t i = 0; i < count; ++i) {
DispatchAsyncEvent(mPendingEvents[i]);
}
mPendingEvents.Clear();
return NS_OK;
}
-bool HTMLMediaElement::IsPotentiallyPlaying() const
+bool
+HTMLMediaElement::IsPotentiallyPlaying() const
{
// TODO:
// playback has not stopped due to errors,
// and the element has not paused for user interaction
- return
- !mPaused &&
- (mReadyState == nsIDOMHTMLMediaElement::HAVE_ENOUGH_DATA ||
- mReadyState == nsIDOMHTMLMediaElement::HAVE_FUTURE_DATA) &&
- !IsPlaybackEnded();
-}
-
-bool HTMLMediaElement::IsPlaybackEnded() const
+ return !mPaused &&
+ (mReadyState == nsIDOMHTMLMediaElement::HAVE_ENOUGH_DATA ||
+ mReadyState == nsIDOMHTMLMediaElement::HAVE_FUTURE_DATA) &&
+ !IsPlaybackEnded();
+}
+
+bool
+HTMLMediaElement::IsPlaybackEnded() const
{
// TODO:
// the current playback position is equal to the effective end of the media resource.
// See bug 449157.
- return mReadyState >= nsIDOMHTMLMediaElement::HAVE_METADATA &&
- mDecoder && mDecoder->IsEnded();
-}
-
-already_AddRefed<nsIPrincipal> HTMLMediaElement::GetCurrentPrincipal()
+ return mReadyState >= nsIDOMHTMLMediaElement::HAVE_METADATA && mDecoder &&
+ mDecoder->IsEnded();
+}
+
+already_AddRefed<nsIPrincipal>
+HTMLMediaElement::GetCurrentPrincipal()
{
if (mDecoder) {
return mDecoder->GetCurrentPrincipal();
}
if (mSrcStream) {
nsCOMPtr<nsIPrincipal> principal = mSrcStream->GetPrincipal();
return principal.forget();
}
return nullptr;
}
-already_AddRefed<nsIPrincipal> HTMLMediaElement::GetCurrentVideoPrincipal()
+already_AddRefed<nsIPrincipal>
+HTMLMediaElement::GetCurrentVideoPrincipal()
{
if (mDecoder) {
return mDecoder->GetCurrentPrincipal();
}
if (mSrcStream) {
nsCOMPtr<nsIPrincipal> principal = mSrcStreamVideoPrincipal;
return principal.forget();
}
return nullptr;
}
-void HTMLMediaElement::NotifyDecoderPrincipalChanged()
+void
+HTMLMediaElement::NotifyDecoderPrincipalChanged()
{
RefPtr<nsIPrincipal> principal = GetCurrentPrincipal();
mDecoder->UpdateSameOriginStatus(!principal || IsCORSSameOrigin());
for (DecoderPrincipalChangeObserver* observer :
- mDecoderPrincipalChangeObservers) {
+ mDecoderPrincipalChangeObservers) {
observer->NotifyDecoderPrincipalChanged();
}
}
-void HTMLMediaElement::AddDecoderPrincipalChangeObserver(DecoderPrincipalChangeObserver* aObserver)
+void
+HTMLMediaElement::AddDecoderPrincipalChangeObserver(
+ DecoderPrincipalChangeObserver* aObserver)
{
mDecoderPrincipalChangeObservers.AppendElement(aObserver);
}
-bool HTMLMediaElement::RemoveDecoderPrincipalChangeObserver(DecoderPrincipalChangeObserver* aObserver)
+bool
+HTMLMediaElement::RemoveDecoderPrincipalChangeObserver(
+ DecoderPrincipalChangeObserver* aObserver)
{
return mDecoderPrincipalChangeObservers.RemoveElement(aObserver);
}
-void HTMLMediaElement::UpdateMediaSize(const nsIntSize& aSize)
+void
+HTMLMediaElement::UpdateMediaSize(const nsIntSize& aSize)
{
if (IsVideo() && mReadyState != HAVE_NOTHING &&
mMediaInfo.mVideo.mDisplay != aSize) {
DispatchAsyncEvent(NS_LITERAL_STRING("resize"));
}
mMediaInfo.mVideo.mDisplay = aSize;
mWatchManager.ManualNotify(&HTMLMediaElement::UpdateReadyStateInternal);
}
-void HTMLMediaElement::UpdateInitialMediaSize(const nsIntSize& aSize)
+void
+HTMLMediaElement::UpdateInitialMediaSize(const nsIntSize& aSize)
{
if (!mMediaInfo.HasVideo()) {
UpdateMediaSize(aSize);
}
if (!mMediaStreamSizeListener) {
return;
}
@@ -6264,20 +6515,26 @@ void HTMLMediaElement::UpdateInitialMedi
return;
}
mSelectedVideoStreamTrack->RemoveDirectListener(mMediaStreamSizeListener);
mMediaStreamSizeListener->Forget();
mMediaStreamSizeListener = nullptr;
}
-void HTMLMediaElement::SuspendOrResumeElement(bool aPauseElement, bool aSuspendEvents)
-{
- LOG(LogLevel::Debug, ("%p SuspendOrResumeElement(pause=%d, suspendEvents=%d) hidden=%d",
- this, aPauseElement, aSuspendEvents, OwnerDoc()->Hidden()));
+void
+HTMLMediaElement::SuspendOrResumeElement(bool aPauseElement,
+ bool aSuspendEvents)
+{
+ LOG(LogLevel::Debug,
+ ("%p SuspendOrResumeElement(pause=%d, suspendEvents=%d) hidden=%d",
+ this,
+ aPauseElement,
+ aSuspendEvents,
+ OwnerDoc()->Hidden()));
if (aPauseElement != mPausedForInactiveDocumentOrChannel) {
mPausedForInactiveDocumentOrChannel = aPauseElement;
UpdateSrcMediaStreamPlaying();
UpdateAudioChannelPlayingState();
if (aPauseElement) {
ReportTelemetry();
ReportEMETelemetry();
@@ -6306,28 +6563,30 @@ void HTMLMediaElement::SuspendOrResumeEl
if (mEventDeliveryPaused) {
mEventDeliveryPaused = false;
DispatchPendingMediaEvents();
}
}
}
}
-bool HTMLMediaElement::IsBeingDestroyed()
+bool
+HTMLMediaElement::IsBeingDestroyed()
{
nsIDocument* ownerDoc = OwnerDoc();
nsIDocShell* docShell = ownerDoc ? ownerDoc->GetDocShell() : nullptr;
bool isBeingDestroyed = false;
if (docShell) {
docShell->IsBeingDestroyed(&isBeingDestroyed);
}
return isBeingDestroyed;
}
-void HTMLMediaElement::NotifyOwnerDocumentActivityChanged()
+void
+HTMLMediaElement::NotifyOwnerDocumentActivityChanged()
{
bool visible = !IsHidden();
if (visible) {
// Visible -> Just pause hidden play time (no-op if already paused).
HiddenVideoStop();
} else if (mPlayTime.IsStarted()) {
// Not visible, play time is running -> Start hidden play time if needed.
HiddenVideoStart();
@@ -6337,114 +6596,118 @@ void HTMLMediaElement::NotifyOwnerDocume
NotifyDecoderActivityChanges();
}
bool pauseElement = ShouldElementBePaused();
SuspendOrResumeElement(pauseElement, !IsActive());
// If the owning document has become inactive we should shutdown the CDM.
if (!OwnerDoc()->IsCurrentActiveDocument() && mMediaKeys) {
- mMediaKeys->Shutdown();
- mMediaKeys = nullptr;
- if (mDecoder) {
- ShutdownDecoder();
- }
- }
+ mMediaKeys->Shutdown();
+ mMediaKeys = nullptr;
+ if (mDecoder) {
+ ShutdownDecoder();
+ }
+ }
AddRemoveSelfReference();
}
-void HTMLMediaElement::AddRemoveSelfReference()
+void
+HTMLMediaElement::AddRemoveSelfReference()
{
// XXX we could release earlier here in many situations if we examined
// which event listeners are attached. Right now we assume there is a
// potential listener for every event. We would also have to keep the
// element alive if it was playing and producing audio output --- right now
// that's covered by the !mPaused check.
nsIDocument* ownerDoc = OwnerDoc();
// See the comment at the top of this file for the explanation of this
// boolean expression.
- bool needSelfReference = !mShuttingDown &&
- ownerDoc->IsActive() &&
- (mDelayingLoadEvent ||
- (!mPaused && mDecoder && !mDecoder->IsEnded()) ||
+ bool needSelfReference =
+ !mShuttingDown && ownerDoc->IsActive() &&
+ (mDelayingLoadEvent || (!mPaused && mDecoder && !mDecoder->IsEnded()) ||
(!mPaused && mSrcStream && !mSrcStream->IsFinished()) ||
- (mDecoder && mDecoder->IsSeeking()) ||
- CanActivateAutoplay() ||
- (mMediaSource ? mProgressTimer :
- mNetworkState == nsIDOMHTMLMediaElement::NETWORK_LOADING));
+ (mDecoder && mDecoder->IsSeeking()) || CanActivateAutoplay() ||
+ (mMediaSource ? mProgressTimer
+ : mNetworkState == nsIDOMHTMLMediaElement::NETWORK_LOADING));
if (needSelfReference != mHasSelfReference) {
mHasSelfReference = needSelfReference;
if (needSelfReference) {
// The shutdown observer will hold a strong reference to us. This
// will do to keep us alive. We need to know about shutdown so that
// we can release our self-reference.
mShutdownObserver->AddRefMediaElement();
} else {
// Dispatch Release asynchronously so that we don't destroy this object
// inside a call stack of method calls on this object
- mMainThreadEventTarget->Dispatch(NewRunnableMethod(
- "dom::HTMLMediaElement::DoRemoveSelfReference",
- this,
- &HTMLMediaElement::DoRemoveSelfReference));
- }
- }
-}
-
-void HTMLMediaElement::DoRemoveSelfReference()
+ mMainThreadEventTarget->Dispatch(
+ NewRunnableMethod("dom::HTMLMediaElement::DoRemoveSelfReference",
+ this,
+ &HTMLMediaElement::DoRemoveSelfReference));
+ }
+ }
+}
+
+void
+HTMLMediaElement::DoRemoveSelfReference()
{
mShutdownObserver->ReleaseMediaElement();
}
-void HTMLMediaElement::NotifyShutdownEvent()
+void
+HTMLMediaElement::NotifyShutdownEvent()
{
mShuttingDown = true;
ResetState();
AddRemoveSelfReference();
}
bool
HTMLMediaElement::IsNodeOfType(uint32_t aFlags) const
{
return !(aFlags & ~(eCONTENT | eMEDIA));
}
-void HTMLMediaElement::DispatchAsyncSourceError(nsIContent* aSourceElement)
+void
+HTMLMediaElement::DispatchAsyncSourceError(nsIContent* aSourceElement)
{
LOG_EVENT(LogLevel::Debug, ("%p Queuing simple source error event", this));
- nsCOMPtr<nsIRunnable> event = new nsSourceErrorEventRunner(this, aSourceElement);
+ nsCOMPtr<nsIRunnable> event =
+ new nsSourceErrorEventRunner(this, aSourceElement);
mMainThreadEventTarget->Dispatch(event.forget());
}
-void HTMLMediaElement::NotifyAddedSource()
+void
+HTMLMediaElement::NotifyAddedSource()
{
// If a source element is inserted as a child of a media element
// that has no src attribute and whose networkState has the value
// NETWORK_EMPTY, the user agent must invoke the media element's
// resource selection algorithm.
if (!HasAttr(kNameSpaceID_None, nsGkAtoms::src) &&
- mNetworkState == nsIDOMHTMLMediaElement::NETWORK_EMPTY)
- {
+ mNetworkState == nsIDOMHTMLMediaElement::NETWORK_EMPTY) {
QueueSelectResourceTask();
}
// A load was paused in the resource selection algorithm, waiting for
// a new source child to be added, resume the resource selection algorithm.
if (mLoadWaitStatus == WAITING_FOR_SOURCE) {
// Rest the flag so we don't queue multiple LoadFromSourceTask() when
// multiple <source> are attached in an event loop.
mLoadWaitStatus = NOT_WAITING;
QueueLoadFromSourceTask();
}
}
-nsIContent* HTMLMediaElement::GetNextSource()
+nsIContent*
+HTMLMediaElement::GetNextSource()
{
mSourceLoadCandidate = nullptr;
while (true) {
if (mSourcePointer == nsINode::GetLastChild()) {
return nullptr; // no more children
}
@@ -6460,24 +6723,29 @@ nsIContent* HTMLMediaElement::GetNextSou
mSourceLoadCandidate = child;
return child;
}
}
NS_NOTREACHED("Execution should not reach here!");
return nullptr;
}
-void HTMLMediaElement::ChangeDelayLoadStatus(bool aDelay)
+void
+HTMLMediaElement::ChangeDelayLoadStatus(bool aDelay)
{
if (mDelayingLoadEvent == aDelay)
return;
mDelayingLoadEvent = aDelay;
- LOG(LogLevel::Debug, ("%p ChangeDelayLoadStatus(%d) doc=0x%p", this, aDelay, mLoadBlockedDoc.get()));
+ LOG(LogLevel::Debug,
+ ("%p ChangeDelayLoadStatus(%d) doc=0x%p",
+ this,
+ aDelay,
+ mLoadBlockedDoc.get()));
if (mDecoder) {
mDecoder->SetLoadInBackground(!aDelay);
}
if (aDelay) {
mLoadBlockedDoc = OwnerDoc();
mLoadBlockedDoc->BlockOnload();
} else {
// mLoadBlockedDoc might be null due to GC unlinking
@@ -6486,17 +6754,18 @@ void HTMLMediaElement::ChangeDelayLoadSt
mLoadBlockedDoc = nullptr;
}
}
// We changed mDelayingLoadEvent which can affect AddRemoveSelfReference
AddRemoveSelfReference();
}
-already_AddRefed<nsILoadGroup> HTMLMediaElement::GetDocumentLoadGroup()
+already_AddRefed<nsILoadGroup>
+HTMLMediaElement::GetDocumentLoadGroup()
{
if (!OwnerDoc()->IsActive()) {
NS_WARNING("Load group requested for media element in inactive document.");
}
return OwnerDoc()->GetDocumentLoadGroup();
}
nsresult
@@ -6515,59 +6784,61 @@ already_AddRefed<TimeRanges>
HTMLMediaElement::Buffered() const
{
media::TimeIntervals buffered =
mDecoder ? mDecoder->GetBuffered() : media::TimeIntervals();
RefPtr<TimeRanges> ranges = new TimeRanges(ToSupports(OwnerDoc()), buffered);
return ranges.forget();
}
-nsresult HTMLMediaElement::GetBuffered(nsIDOMTimeRanges** aBuffered)
+nsresult
+HTMLMediaElement::GetBuffered(nsIDOMTimeRanges** aBuffered)
{
RefPtr<TimeRanges> ranges = Buffered();
ranges.forget(aBuffered);
return NS_OK;
}
-void HTMLMediaElement::SetRequestHeaders(nsIHttpChannel* aChannel)
+void
+HTMLMediaElement::SetRequestHeaders(nsIHttpChannel* aChannel)
{
// Send Accept header for video and audio types only (Bug 489071)
SetAcceptHeader(aChannel);
// Apache doesn't send Content-Length when gzip transfer encoding is used,
// which prevents us from estimating the video length (if explicit Content-Duration
// and a length spec in the container are not present either) and from seeking.
// So, disable the standard "Accept-Encoding: gzip,deflate" that we usually send.
// See bug 614760.
- DebugOnly<nsresult> rv =
- aChannel->SetRequestHeader(NS_LITERAL_CSTRING("Accept-Encoding"),
- EmptyCString(), false);
+ DebugOnly<nsresult> rv = aChannel->SetRequestHeader(
+ NS_LITERAL_CSTRING("Accept-Encoding"), EmptyCString(), false);
MOZ_ASSERT(NS_SUCCEEDED(rv));
// Set the Referer header
rv = aChannel->SetReferrerWithPolicy(OwnerDoc()->GetDocumentURI(),
OwnerDoc()->GetReferrerPolicy());
MOZ_ASSERT(NS_SUCCEEDED(rv));
}
-void HTMLMediaElement::FireTimeUpdate(bool aPeriodic)
+void
+HTMLMediaElement::FireTimeUpdate(bool aPeriodic)
{
NS_ASSERTION(NS_IsMainThread(), "Should be on main thread.");
TimeStamp now = TimeStamp::Now();
double time = CurrentTime();
// Fire a timeupdate event if this is not a periodic update (i.e. it's a
// timeupdate event mandated by the spec), or if it's a periodic update
// and TIMEUPDATE_MS has passed since the last timeupdate event fired and
// the time has changed.
- if (!aPeriodic ||
- (mLastCurrentTime != time &&
- (mTimeUpdateTime.IsNull() ||
- now - mTimeUpdateTime >= TimeDuration::FromMilliseconds(TIMEUPDATE_MS)))) {
+ if (!aPeriodic || (mLastCurrentTime != time &&
+ (mTimeUpdateTime.IsNull() ||
+ now - mTimeUpdateTime >=
+ TimeDuration::FromMilliseconds(TIMEUPDATE_MS)))) {
DispatchAsyncEvent(NS_LITERAL_STRING("timeupdate"));
mTimeUpdateTime = now;
mLastCurrentTime = time;
}
if (mFragmentEnd >= 0.0 && time >= mFragmentEnd) {
Pause();
mFragmentEnd = -1.0;
mFragmentStart = -1.0;
@@ -6578,17 +6849,18 @@ void HTMLMediaElement::FireTimeUpdate(bo
// Here mTextTrackManager can be null if the cycle collector has unlinked
// us before our parent. In that case UnbindFromTree will call us
// when our parent is unlinked.
if (mTextTrackManager) {
mTextTrackManager->TimeMarchesOn();
}
}
-MediaStream* HTMLMediaElement::GetSrcMediaStream() const
+MediaStream*
+HTMLMediaElement::GetSrcMediaStream() const
{
if (!mSrcStream) {
return nullptr;
}
return mSrcStream->GetPlaybackStream();
}
MediaError*
@@ -6598,83 +6870,91 @@ HTMLMediaElement::GetError() const
}
void
HTMLMediaElement::OpenUnsupportedMediaWithExternalAppIfNeeded() const
{
mErrorSink->MaybeOpenUnsupportedMediaForOwner();
}
-void HTMLMediaElement::GetCurrentSpec(nsCString& aString)
+void
+HTMLMediaElement::GetCurrentSpec(nsCString& aString)
{
if (mLoadingSrc) {
mLoadingSrc->GetSpec(aString);
} else {
aString.Truncate();
}
}
double
HTMLMediaElement::MozFragmentEnd()
{
double duration = Duration();
// If there is no end fragment, or the fragment end is greater than the
// duration, return the duration.
- return (mFragmentEnd < 0.0 || mFragmentEnd > duration) ? duration : mFragmentEnd;
-}
-
-NS_IMETHODIMP HTMLMediaElement::GetMozFragmentEnd(double* aTime)
+ return (mFragmentEnd < 0.0 || mFragmentEnd > duration) ? duration
+ : mFragmentEnd;
+}
+
+NS_IMETHODIMP
+HTMLMediaElement::GetMozFragmentEnd(double* aTime)
{
*aTime = MozFragmentEnd();
return NS_OK;
}
-static double ClampPlaybackRate(double aPlaybackRate)
+static double
+ClampPlaybackRate(double aPlaybackRate)
{
MOZ_ASSERT(aPlaybackRate >= 0.0);
if (aPlaybackRate == 0.0) {
return aPlaybackRate;
}
if (aPlaybackRate < MIN_PLAYBACKRATE) {
return MIN_PLAYBACKRATE;
}
if (aPlaybackRate > MAX_PLAYBACKRATE) {
return MAX_PLAYBACKRATE;
}
return aPlaybackRate;
}
-NS_IMETHODIMP HTMLMediaElement::GetDefaultPlaybackRate(double* aDefaultPlaybackRate)
+NS_IMETHODIMP
+HTMLMediaElement::GetDefaultPlaybackRate(double* aDefaultPlaybackRate)
{
*aDefaultPlaybackRate = DefaultPlaybackRate();
return NS_OK;
}
void
-HTMLMediaElement::SetDefaultPlaybackRate(double aDefaultPlaybackRate, ErrorResult& aRv)
+HTMLMediaElement::SetDefaultPlaybackRate(double aDefaultPlaybackRate,
+ ErrorResult& aRv)
{
if (aDefaultPlaybackRate < 0) {
aRv.Throw(NS_ERROR_NOT_IMPLEMENTED);
return;
}
mDefaultPlaybackRate = ClampPlaybackRate(aDefaultPlaybackRate);
DispatchAsyncEvent(NS_LITERAL_STRING("ratechange"));
}
-NS_IMETHODIMP HTMLMediaElement::SetDefaultPlaybackRate(double aDefaultPlaybackRate)
+NS_IMETHODIMP
+HTMLMediaElement::SetDefaultPlaybackRate(double aDefaultPlaybackRate)
{
ErrorResult rv;
SetDefaultPlaybackRate(aDefaultPlaybackRate, rv);
return rv.StealNSResult();
}
-NS_IMETHODIMP HTMLMediaElement::GetPlaybackRate(double* aPlaybackRate)
+NS_IMETHODIMP
+HTMLMediaElement::GetPlaybackRate(double* aPlaybackRate)
{
*aPlaybackRate = PlaybackRate();
return NS_OK;
}
void
HTMLMediaElement::SetPlaybackRate(double aPlaybackRate, ErrorResult& aRv)
{
@@ -6700,39 +6980,43 @@ HTMLMediaElement::SetPlaybackRate(double
}
if (mDecoder) {
mDecoder->SetPlaybackRate(ClampPlaybackRate(mPlaybackRate));
}
DispatchAsyncEvent(NS_LITERAL_STRING("ratechange"));
}
-NS_IMETHODIMP HTMLMediaElement::SetPlaybackRate(double aPlaybackRate)
+NS_IMETHODIMP
+HTMLMediaElement::SetPlaybackRate(double aPlaybackRate)
{
ErrorResult rv;
SetPlaybackRate(aPlaybackRate, rv);
return rv.StealNSResult();
}
-NS_IMETHODIMP HTMLMediaElement::GetMozPreservesPitch(bool* aPreservesPitch)
+NS_IMETHODIMP
+HTMLMediaElement::GetMozPreservesPitch(bool* aPreservesPitch)
{
*aPreservesPitch = MozPreservesPitch();
return NS_OK;
}
-NS_IMETHODIMP HTMLMediaElement::SetMozPreservesPitch(bool aPreservesPitch)
+NS_IMETHODIMP
+HTMLMediaElement::SetMozPreservesPitch(bool aPreservesPitch)
{
mPreservesPitch = aPreservesPitch;
if (mDecoder) {
mDecoder->SetPreservesPitch(mPreservesPitch);
}
return NS_OK;
}
-ImageContainer* HTMLMediaElement::GetImageContainer()
+ImageContainer*
+HTMLMediaElement::GetImageContainer()
{
VideoFrameContainer* container = GetVideoFrameContainer();
return container ? container->GetImageContainer() : nullptr;
}
void
HTMLMediaElement::UpdateAudioChannelPlayingState(bool aForcePlaying)
{
@@ -6741,46 +7025,50 @@ HTMLMediaElement::UpdateAudioChannelPlay
}
}
bool
HTMLMediaElement::IsAllowedToPlay()
{
// Prevent media element from being auto-started by a script when
// media.autoplay.enabled=false
- if (!mHasUserInteraction &&
- !IsAutoplayEnabled() &&
+ if (!mHasUserInteraction && !IsAutoplayEnabled() &&
!EventStateManager::IsHandlingUserInput()) {
#if defined(MOZ_WIDGET_ANDROID)
- nsContentUtils::DispatchTrustedEvent(OwnerDoc(),
- static_cast<nsIContent*>(this),
- NS_LITERAL_STRING("MozAutoplayMediaBlocked"),
- false,
- false);
+ nsContentUtils::DispatchTrustedEvent(
+ OwnerDoc(),
+ static_cast<nsIContent*>(this),
+ NS_LITERAL_STRING("MozAutoplayMediaBlocked"),
+ false,
+ false);
#endif
return false;
}
// Check our custom playback policy.
if (mAudioChannelWrapper) {
// Note: SUSPENDED_PAUSE and SUSPENDED_BLOCK will be merged into one single state.
- if (mAudioChannelWrapper->GetSuspendType() == nsISuspendedTypes::SUSPENDED_PAUSE ||
- mAudioChannelWrapper->GetSuspendType() == nsISuspendedTypes::SUSPENDED_BLOCK) {
+ if (mAudioChannelWrapper->GetSuspendType() ==
+ nsISuspendedTypes::SUSPENDED_PAUSE ||
+ mAudioChannelWrapper->GetSuspendType() ==
+ nsISuspendedTypes::SUSPENDED_BLOCK) {
return false;
}
return true;
}
// If the mAudioChannelWrapper doesn't exist that means the CC happened.
return false;
}
-static const char* VisibilityString(Visibility aVisibility) {
- switch(aVisibility) {
+static const char*
+VisibilityString(Visibility aVisibility)
+{
+ switch (aVisibility) {
case Visibility::UNTRACKED: {
return "UNTRACKED";
}
case Visibility::APPROXIMATELY_NONVISIBLE: {
return "APPROXIMATELY_NONVISIBLE";
}
case Visibility::APPROXIMATELY_VISIBLE: {
return "APPROXIMATELY_VISIBLE";
@@ -6788,29 +7076,29 @@ static const char* VisibilityString(Visi
}
return "NAN";
}
void
HTMLMediaElement::OnVisibilityChange(Visibility aNewVisibility)
{
- LOG(LogLevel::Debug, ("OnVisibilityChange(): %s\n",
- VisibilityString(aNewVisibility)));
+ LOG(LogLevel::Debug,
+ ("OnVisibilityChange(): %s\n", VisibilityString(aNewVisibility)));
mVisibilityState = aNewVisibility;
if (!mDecoder) {
return;
}
switch (aNewVisibility) {
case Visibility::UNTRACKED: {
- MOZ_ASSERT_UNREACHABLE("Shouldn't notify for untracked visibility");
- return;
+ MOZ_ASSERT_UNREACHABLE("Shouldn't notify for untracked visibility");
+ return;
}
case Visibility::APPROXIMATELY_NONVISIBLE: {
if (mPlayTime.IsStarted()) {
// Not visible, play time is running -> Start hidden play time if needed.
HiddenVideoStart();
}
break;
}
@@ -6835,32 +7123,36 @@ HTMLMediaElement::ContainsRestrictedCont
{
return GetMediaKeys() != nullptr;
}
already_AddRefed<Promise>
HTMLMediaElement::SetMediaKeys(mozilla::dom::MediaKeys* aMediaKeys,
ErrorResult& aRv)
{
- LOG(LogLevel::Debug, ("%p SetMediaKeys(%p) mMediaKeys=%p mDecoder=%p",
- this, aMediaKeys, mMediaKeys.get(), mDecoder.get()));
+ LOG(LogLevel::Debug,
+ ("%p SetMediaKeys(%p) mMediaKeys=%p mDecoder=%p",
+ this,
+ aMediaKeys,
+ mMediaKeys.get(),
+ mDecoder.get()));
if (MozAudioCaptured()) {
aRv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
return nullptr;
}
nsCOMPtr<nsIGlobalObject> global =
do_QueryInterface(OwnerDoc()->GetInnerWindow());
if (!global) {
aRv.Throw(NS_ERROR_UNEXPECTED);
return nullptr;
}
- RefPtr<DetailedPromise> promise = DetailedPromise::Create(global, aRv,
- NS_LITERAL_CSTRING("HTMLMediaElement.setMediaKeys"));
+ RefPtr<DetailedPromise> promise = DetailedPromise::Create(
+ global, aRv, NS_LITERAL_CSTRING("HTMLMediaElement.setMediaKeys"));
if (aRv.Failed()) {
return nullptr;
}
// 1. If mediaKeys and the mediaKeys attribute are the same object,
// return a resolved promise.
if (mMediaKeys == aMediaKeys) {
promise->MaybeResolveWithUndefined();
@@ -6876,68 +7168,76 @@ HTMLMediaElement::SetMediaKeys(mozilla::
// 5. Run the following steps in parallel:
// 5.1 If mediaKeys is not null, CDM instance represented by mediaKeys is
// already in use by another media element, and the user agent is unable
// to use it with this element, let this object's attaching media keys
// value be false and reject promise with a new DOMException whose name
// is QuotaExceededError.
if (aMediaKeys && aMediaKeys->IsBoundToMediaElement()) {
- promise->MaybeReject(NS_ERROR_DOM_QUOTA_EXCEEDED_ERR,
- NS_LITERAL_CSTRING("MediaKeys object is already bound to another HTMLMediaElement"));
+ promise->MaybeReject(
+ NS_ERROR_DOM_QUOTA_EXCEEDED_ERR,
+ NS_LITERAL_CSTRING(
+ "MediaKeys object is already bound to another HTMLMediaElement"));
return promise.forget();
}
// 5.2 If the mediaKeys attribute is not null, run the following steps:
if (mMediaKeys) {
// 5.2.1 If the user agent or CDM do not support removing the association,
// let this object's attaching media keys value be false and reject promise
// with a new DOMException whose name is NotSupportedError.
// 5.2.2 If the association cannot currently be removed, let this object's
// attaching media keys value be false and reject promise with a new
// DOMException whose name is InvalidStateError.
if (mDecoder) {
// We don't support swapping out the MediaKeys once we've started to
// setup the playback pipeline. Note this also means we don't need to worry
// about handling disassociating the MediaKeys from the MediaDecoder.
- promise->MaybeReject(NS_ERROR_DOM_INVALID_STATE_ERR,
- NS_LITERAL_CSTRING("Can't change MediaKeys on HTMLMediaElement after load has started"));
+ promise->MaybeReject(
+ NS_ERROR_DOM_INVALID_STATE_ERR,
+ NS_LITERAL_CSTRING(
+ "Can't change MediaKeys on HTMLMediaElement after load has started"));
return promise.forget();
}
// 5.2.3 Stop using the CDM instance represented by the mediaKeys attribute
// to decrypt media data and remove the association with the media element.
mMediaKeys->Unbind();
mMediaKeys = nullptr;
// 5.2.4 If the preceding step failed, let this object's attaching media
// keys value be false and reject promise with a new DOMException whose
// name is the appropriate error name.
}
// 5.3. If mediaKeys is not null, run the following steps:
if (aMediaKeys) {
if (!aMediaKeys->GetCDMProxy()) {
- promise->MaybeReject(NS_ERROR_DOM_INVALID_STATE_ERR,
- NS_LITERAL_CSTRING("CDM crashed before binding MediaKeys object to HTMLMediaElement"));
+ promise->MaybeReject(
+ NS_ERROR_DOM_INVALID_STATE_ERR,
+ NS_LITERAL_CSTRING(
+ "CDM crashed before binding MediaKeys object to HTMLMediaElement"));
return promise.forget();
}
// 5.3.1 Associate the CDM instance represented by mediaKeys with the
// media element for decrypting media data.
if (NS_FAILED(aMediaKeys->Bind(this))) {
// 5.3.2 If the preceding step failed, run the following steps:
// 5.3.2.1 Set the mediaKeys attribute to null.
mMediaKeys = nullptr;
// 5.3.2.2 Let this object's attaching media keys value be false.
// 5.3.2.3 Reject promise with a new DOMException whose name is
// the appropriate error name.
- promise->MaybeReject(NS_ERROR_DOM_INVALID_STATE_ERR,
- NS_LITERAL_CSTRING("Failed to bind MediaKeys object to HTMLMediaElement"));
+ promise->MaybeReject(
+ NS_ERROR_DOM_INVALID_STATE_ERR,
+ NS_LITERAL_CSTRING(
+ "Failed to bind MediaKeys object to HTMLMediaElement"));
return promise.forget();
}
// 5.3.3 Queue a task to run the "Attempt to Resume Playback If Necessary"
// algorithm on the media element.
// Note: Setting the CDMProxy on the MediaDecoder will unblock playback.
if (mDecoder) {
mDecoder->SetCDMProxy(aMediaKeys->GetCDMProxy());
}
@@ -6959,38 +7259,42 @@ EventHandlerNonNull*
HTMLMediaElement::GetOnencrypted()
{
return EventTarget::GetEventHandler(nsGkAtoms::onencrypted, EmptyString());
}
void
HTMLMediaElement::SetOnencrypted(EventHandlerNonNull* aCallback)
{
- EventTarget::SetEventHandler(nsGkAtoms::onencrypted, EmptyString(), aCallback);
+ EventTarget::SetEventHandler(
+ nsGkAtoms::onencrypted, EmptyString(), aCallback);
}
EventHandlerNonNull*
HTMLMediaElement::GetOnwaitingforkey()
{
- return EventTarget::GetEventHandler(nsGkAtoms::onwaitingforkey, EmptyString());
+ return EventTarget::GetEventHandler(nsGkAtoms::onwaitingforkey,
+ EmptyString());
}
void
HTMLMediaElement::SetOnwaitingforkey(EventHandlerNonNull* aCallback)
{
- EventTarget::SetEventHandler(nsGkAtoms::onwaitingforkey, EmptyString(), aCallback);
+ EventTarget::SetEventHandler(
+ nsGkAtoms::onwaitingforkey, EmptyString(), aCallback);
}
void
HTMLMediaElement::DispatchEncrypted(const nsTArray<uint8_t>& aInitData,
const nsAString& aInitDataType)
{
LOG(LogLevel::Debug,
("%p DispatchEncrypted initDataType='%s'",
- this, NS_ConvertUTF16toUTF8(aInitDataType).get()));
+ this,
+ NS_ConvertUTF16toUTF8(aInitDataType).get()));
if (mReadyState == nsIDOMHTMLMediaElement::HAVE_NOTHING) {
// Ready state not HAVE_METADATA (yet), don't dispatch encrypted now.
// Queueing for later dispatch in MetadataLoaded.
mPendingEncryptedInitData.AddInitData(aInitDataType, aInitData);
return;
}
@@ -7051,48 +7355,52 @@ HTMLMediaElement::NotifyWaitingForKey()
UpdateReadyStateInternal();
}
}
AudioTrackList*
HTMLMediaElement::AudioTracks()
{
if (!mAudioTrackList) {
- nsCOMPtr<nsPIDOMWindowInner> window = do_QueryInterface(OwnerDoc()->GetParentObject());
+ nsCOMPtr<nsPIDOMWindowInner> window =
+ do_QueryInterface(OwnerDoc()->GetParentObject());
mAudioTrackList = new AudioTrackList(window, this);
}
return mAudioTrackList;
}
VideoTrackList*
HTMLMediaElement::VideoTracks()
{
if (!mVideoTrackList) {
- nsCOMPtr<nsPIDOMWindowInner> window = do_QueryInterface(OwnerDoc()->GetParentObject());
+ nsCOMPtr<nsPIDOMWindowInner> window =
+ do_QueryInterface(OwnerDoc()->GetParentObject());
mVideoTrackList = new VideoTrackList(window, this);
}
return mVideoTrackList;
}
TextTrackList*
HTMLMediaElement::GetTextTracks()
{
return GetOrCreateTextTrackManager()->GetTextTracks();
}
already_AddRefed<TextTrack>
HTMLMediaElement::AddTextTrack(TextTrackKind aKind,
const nsAString& aLabel,
const nsAString& aLanguage)
{
- return
- GetOrCreateTextTrackManager()->AddTextTrack(aKind, aLabel, aLanguage,
- TextTrackMode::Hidden,
- TextTrackReadyState::Loaded,
- TextTrackSource::AddTextTrack);
+ return GetOrCreateTextTrackManager()->AddTextTrack(
+ aKind,
+ aLabel,
+ aLanguage,
+ TextTrackMode::Hidden,
+ TextTrackReadyState::Loaded,
+ TextTrackSource::AddTextTrack);
}
void
HTMLMediaElement::PopulatePendingTextTrackList()
{
if (mTextTrackManager) {
mTextTrackManager->PopulatePendingList();
}
@@ -7114,45 +7422,46 @@ HTMLMediaElement::NextFrameStatus()
if (mDecoder) {
return mDecoder->NextFrameStatus();
} else if (mMediaStreamListener) {
return mMediaStreamListener->NextFrameStatus();
}
return NEXT_FRAME_UNINITIALIZED;
}
-
void
HTMLMediaElement::SetDecoder(MediaDecoder* aDecoder)
{
MOZ_ASSERT(aDecoder); // Use ShutdownDecoder() to clear.
if (mDecoder) {
ShutdownDecoder();
}
mDecoder = aDecoder;
}
float
HTMLMediaElement::ComputedVolume() const
{
- return mMuted ? 0.0f : mAudioChannelWrapper ?
- mAudioChannelWrapper->GetEffectiveVolume() : mVolume;
+ return mMuted
+ ? 0.0f
+ : mAudioChannelWrapper ? mAudioChannelWrapper->GetEffectiveVolume()
+ : mVolume;
}
bool
HTMLMediaElement::ComputedMuted() const
{
return (mMuted & MUTED_BY_AUDIO_CHANNEL);
}
nsSuspendedTypes
HTMLMediaElement::ComputedSuspended() const
{
- return mAudioChannelWrapper ?
- mAudioChannelWrapper->GetSuspendType() : nsISuspendedTypes::NONE_SUSPENDED;
+ return mAudioChannelWrapper ? mAudioChannelWrapper->GetSuspendType()
+ : nsISuspendedTypes::NONE_SUSPENDED;
}
bool
HTMLMediaElement::IsCurrentlyPlaying() const
{
// We have playable data, but we still need to check whether data is "real"
// current data.
return mReadyState >= nsIDOMHTMLMediaElement::HAVE_CURRENT_DATA &&
@@ -7215,27 +7524,28 @@ HTMLMediaElement::AudioCaptureStreamChan
if (aCapture && !mCaptureStreamPort) {
nsCOMPtr<nsPIDOMWindowInner> window = OwnerDoc()->GetInnerWindow();
if (!OwnerDoc()->GetInnerWindow()) {
return;
}
uint64_t id = window->WindowID();
- MediaStreamGraph* msg =
- MediaStreamGraph::GetInstance(MediaStreamGraph::AUDIO_THREAD_DRIVER, window);
+ MediaStreamGraph* msg = MediaStreamGraph::GetInstance(
+ MediaStreamGraph::AUDIO_THREAD_DRIVER, window);
if (GetSrcMediaStream()) {
mCaptureStreamPort = msg->ConnectToCaptureStream(id, GetSrcMediaStream());
} else {
RefPtr<DOMMediaStream> stream =
CaptureStreamInternal(StreamCaptureBehavior::CONTINUE_WHEN_ENDED,
StreamCaptureType::CAPTURE_AUDIO,
msg);
- mCaptureStreamPort = msg->ConnectToCaptureStream(id, stream->GetPlaybackStream());
+ mCaptureStreamPort =
+ msg->ConnectToCaptureStream(id, stream->GetPlaybackStream());
}
} else if (!aCapture && mCaptureStreamPort) {
if (mDecoder) {
ProcessedMediaStream* ps =
mCaptureStreamPort->GetSource()->AsProcessedStream();
MOZ_ASSERT(ps);
for (uint32_t i = 0; i < mOutputStreams.Length(); i++) {
@@ -7270,106 +7580,121 @@ HTMLMediaElement::MarkAsContentSource(Ca
// 0 = ALL_VISIBLE
Telemetry::Accumulate(Telemetry::VIDEO_AS_CONTENT_SOURCE, 0);
} else {
// 1 = ALL_INVISIBLE
Telemetry::Accumulate(Telemetry::VIDEO_AS_CONTENT_SOURCE, 1);
if (IsInUncomposedDoc()) {
// 0 = ALL_IN_TREE
- Telemetry::Accumulate(Telemetry::VIDEO_AS_CONTENT_SOURCE_IN_TREE_OR_NOT, 0);
+ Telemetry::Accumulate(Telemetry::VIDEO_AS_CONTENT_SOURCE_IN_TREE_OR_NOT,
+ 0);
} else {
// 1 = ALL_NOT_IN_TREE
- Telemetry::Accumulate(Telemetry::VIDEO_AS_CONTENT_SOURCE_IN_TREE_OR_NOT, 1);
+ Telemetry::Accumulate(Telemetry::VIDEO_AS_CONTENT_SOURCE_IN_TREE_OR_NOT,
+ 1);
}
}
switch (aAPI) {
case CallerAPI::DRAW_IMAGE: {
if (isVisible) {
// 2 = drawImage_VISIBLE
Telemetry::Accumulate(Telemetry::VIDEO_AS_CONTENT_SOURCE, 2);
} else {
// 3 = drawImage_INVISIBLE
Telemetry::Accumulate(Telemetry::VIDEO_AS_CONTENT_SOURCE, 3);
if (IsInUncomposedDoc()) {
// 2 = drawImage_IN_TREE
- Telemetry::Accumulate(Telemetry::VIDEO_AS_CONTENT_SOURCE_IN_TREE_OR_NOT, 2);
+ Telemetry::Accumulate(
+ Telemetry::VIDEO_AS_CONTENT_SOURCE_IN_TREE_OR_NOT, 2);
} else {
// 3 = drawImage_NOT_IN_TREE
- Telemetry::Accumulate(Telemetry::VIDEO_AS_CONTENT_SOURCE_IN_TREE_OR_NOT, 3);
+ Telemetry::Accumulate(
+ Telemetry::VIDEO_AS_CONTENT_SOURCE_IN_TREE_OR_NOT, 3);
}
}
break;
}
case CallerAPI::CREATE_PATTERN: {
if (isVisible) {
// 4 = createPattern_VISIBLE
Telemetry::Accumulate(Telemetry::VIDEO_AS_CONTENT_SOURCE, 4);
} else {
// 5 = createPattern_INVISIBLE
Telemetry::Accumulate(Telemetry::VIDEO_AS_CONTENT_SOURCE, 5);
if (IsInUncomposedDoc()) {
// 4 = createPattern_IN_TREE
- Telemetry::Accumulate(Telemetry::VIDEO_AS_CONTENT_SOURCE_IN_TREE_OR_NOT, 4);
+ Telemetry::Accumulate(
+ Telemetry::VIDEO_AS_CONTENT_SOURCE_IN_TREE_OR_NOT, 4);
} else {
// 5 = createPattern_NOT_IN_TREE
- Telemetry::Accumulate(Telemetry::VIDEO_AS_CONTENT_SOURCE_IN_TREE_OR_NOT, 5);
+ Telemetry::Accumulate(
+ Telemetry::VIDEO_AS_CONTENT_SOURCE_IN_TREE_OR_NOT, 5);
}
}
break;
}
case CallerAPI::CREATE_IMAGEBITMAP: {
if (isVisible) {
// 6 = createImageBitmap_VISIBLE
Telemetry::Accumulate(Telemetry::VIDEO_AS_CONTENT_SOURCE, 6);
} else {
// 7 = createImageBitmap_INVISIBLE
Telemetry::Accumulate(Telemetry::VIDEO_AS_CONTENT_SOURCE, 7);
if (IsInUncomposedDoc()) {
// 6 = createImageBitmap_IN_TREE
- Telemetry::Accumulate(Telemetry::VIDEO_AS_CONTENT_SOURCE_IN_TREE_OR_NOT, 6);
+ Telemetry::Accumulate(
+ Telemetry::VIDEO_AS_CONTENT_SOURCE_IN_TREE_OR_NOT, 6);
} else {
// 7 = createImageBitmap_NOT_IN_TREE
- Telemetry::Accumulate(Telemetry::VIDEO_AS_CONTENT_SOURCE_IN_TREE_OR_NOT, 7);
+ Telemetry::Accumulate(
+ Telemetry::VIDEO_AS_CONTENT_SOURCE_IN_TREE_OR_NOT, 7);
}
}
break;
}
case CallerAPI::CAPTURE_STREAM: {
if (isVisible) {
// 8 = captureStream_VISIBLE
Telemetry::Accumulate(Telemetry::VIDEO_AS_CONTENT_SOURCE, 8);
} else {
// 9 = captureStream_INVISIBLE
Telemetry::Accumulate(Telemetry::VIDEO_AS_CONTENT_SOURCE, 9);
if (IsInUncomposedDoc()) {
// 8 = captureStream_IN_TREE
- Telemetry::Accumulate(Telemetry::VIDEO_AS_CONTENT_SOURCE_IN_TREE_OR_NOT, 8);
+ Telemetry::Accumulate(
+ Telemetry::VIDEO_AS_CONTENT_SOURCE_IN_TREE_OR_NOT, 8);
} else {
// 9 = captureStream_NOT_IN_TREE
- Telemetry::Accumulate(Telemetry::VIDEO_AS_CONTENT_SOURCE_IN_TREE_OR_NOT, 9);
+ Telemetry::Accumulate(
+ Telemetry::VIDEO_AS_CONTENT_SOURCE_IN_TREE_OR_NOT, 9);
}
}
break;
}
}
LOG(LogLevel::Debug,
("%p Log VIDEO_AS_CONTENT_SOURCE: visibility = %u, API: '%d' and 'All'",
- this, isVisible, static_cast<int>(aAPI)));
+ this,
+ isVisible,
+ static_cast<int>(aAPI)));
if (!isVisible) {
LOG(LogLevel::Debug,
- ("%p Log VIDEO_AS_CONTENT_SOURCE_IN_TREE_OR_NOT: inTree = %u, API: '%d' and 'All'",
- this, IsInUncomposedDoc(), static_cast<int>(aAPI)));
+ ("%p Log VIDEO_AS_CONTENT_SOURCE_IN_TREE_OR_NOT: inTree = %u, API: "
+ "'%d' and 'All'",
+ this,
+ IsInUncomposedDoc(),
+ static_cast<int>(aAPI)));
}
}
void
HTMLMediaElement::UpdateCustomPolicyAfterPlayed()
{
OpenUnsupportedMediaWithExternalAppIfNeeded();
if (mAudioChannelWrapper) {
@@ -7397,51 +7722,49 @@ HTMLMediaElement::NotifyAboutPlaying()
// Stick to the DispatchAsyncEvent() call path for now because we want to
// trigger some telemetry-related codes in the DispatchAsyncEvent() method.
DispatchAsyncEvent(NS_LITERAL_STRING("playing"));
}
already_AddRefed<Promise>
HTMLMediaElement::CreateDOMPromise(ErrorResult& aRv) const
{
- nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(OwnerDoc()->GetInnerWindow());
+ nsCOMPtr<nsIGlobalObject> global =
+ do_QueryInterface(OwnerDoc()->GetInnerWindow());
if (!global) {
aRv.Throw(NS_ERROR_UNEXPECTED);
return nullptr;
}
return Promise::Create(global, aRv);
}
void
HTMLMediaElement::AsyncResolvePendingPlayPromises()
{
if (mShuttingDown) {
return;
}
- nsCOMPtr<nsIRunnable> event
- = new nsResolveOrRejectPendingPlayPromisesRunner(this,
- TakePendingPlayPromises());
+ nsCOMPtr<nsIRunnable> event = new nsResolveOrRejectPendingPlayPromisesRunner(
+ this, TakePendingPlayPromises());
mMainThreadEventTarget->Dispatch(event.forget());
}
void
HTMLMediaElement::AsyncRejectPendingPlayPromises(nsresult aError)
{
if (mShuttingDown) {
return;
}
- nsCOMPtr<nsIRunnable> event
- = new nsResolveOrRejectPendingPlayPromisesRunner(this,
- TakePendingPlayPromises(),
- aError);
+ nsCOMPtr<nsIRunnable> event = new nsResolveOrRejectPendingPlayPromisesRunner(
+ this, TakePendingPlayPromises(), aError);
mMainThreadEventTarget->Dispatch(event.forget());
}
void
HTMLMediaElement::GetEMEInfo(nsString& aEMEInfo)
{
if (!mMediaKeys) {
@@ -7459,19 +7782,18 @@ HTMLMediaElement::GetEMEInfo(nsString& a
aEMEInfo.AppendLiteral(" SessionsInfo=");
aEMEInfo.Append(sessionsInfo);
}
void
HTMLMediaElement::NotifyDecoderActivityChanges() const
{
if (mDecoder) {
- mDecoder->NotifyOwnerActivityChanged(!IsHidden(),
- mVisibilityState,
- IsInUncomposedDoc());
+ mDecoder->NotifyOwnerActivityChanged(
+ !IsHidden(), mVisibilityState, IsInUncomposedDoc());
}
}
nsIDocument*
HTMLMediaElement::GetDocument() const
{
return OwnerDoc();
}
@@ -7484,26 +7806,26 @@ HTMLMediaElement::ConstructMediaTracks(c
}
mMediaTracksConstructed = true;
AudioTrackList* audioList = AudioTracks();
if (audioList && aInfo->HasAudio()) {
const TrackInfo& info = aInfo->mAudio;
RefPtr<AudioTrack> track = MediaTrackList::CreateAudioTrack(
- info.mId, info.mKind, info.mLabel, info.mLanguage, info.mEnabled);
+ info.mId, info.mKind, info.mLabel, info.mLanguage, info.mEnabled);
audioList->AddTrack(track);
}
VideoTrackList* videoList = VideoTracks();
if (videoList && aInfo->HasVideo()) {
const TrackInfo& info = aInfo->mVideo;
RefPtr<VideoTrack> track = MediaTrackList::CreateVideoTrack(
- info.mId, info.mKind, info.mLabel, info.mLanguage);
+ info.mId, info.mKind, info.mLabel, info.mLanguage);
videoList->AddTrack(track);
track->SetEnabledInternal(info.mEnabled, MediaTrack::FIRE_NO_EVENTS);
}
}
void
HTMLMediaElement::RemoveMediaTracks()
@@ -7530,16 +7852,17 @@ public:
already_AddRefed<nsPIDOMWindowInner> GetPluginCrashedEventTarget() override
{
MOZ_ASSERT(NS_IsMainThread()); // WeakPtr isn't thread safe.
if (!mElement) {
return nullptr;
}
return do_AddRef(mElement->OwnerDoc()->GetInnerWindow());
}
+
private:
WeakPtr<HTMLMediaElement> mElement;
};
already_AddRefed<GMPCrashHelper>
HTMLMediaElement::CreateGMPCrashHelper()
{
return MakeAndAddRef<MediaElementGMPCrashHelper>(this);
@@ -7555,17 +7878,17 @@ HTMLMediaElement::MarkAsTainted()
}
}
bool
HasDebuggerOrTabsPrivilege(JSContext* aCx, JSObject* aObj)
{
return nsContentUtils::CallerHasPermission(aCx, nsGkAtoms::debugger) ||
nsContentUtils::CallerHasPermission(aCx, nsGkAtoms::tabs);
- }
+}
void
HTMLMediaElement::AsyncResolveSeekDOMPromiseIfExists()
{
MOZ_ASSERT(NS_IsMainThread());
if (mSeekDOMPromise) {
RefPtr<dom::Promise> promise = mSeekDOMPromise.forget();
nsCOMPtr<nsIRunnable> r = NS_NewRunnableFunction(