From e1b8d01dd19678b3806b81c4d1a6fdfd4d49cb88 Mon Sep 17 00:00:00 2001 From: Andreas Pehrson Date: Tue, 2 Feb 2016 13:14:13 +0800 Subject: [PATCH] Bug 1208371 - Hook up DecodedStream with PrincipalHandle. r=mt,jwwang MozReview-Commit-ID: 1LmiFyfjhsr --HG-- extra : rebase_source : e1ceca65cd1f5ff64ab6fff8fafc1ddd08f44b87 --- dom/media/MediaDecoder.cpp | 4 +++ dom/media/MediaDecoder.h | 7 ++++++ dom/media/MediaDecoderStateMachine.cpp | 7 +++++- dom/media/MediaDecoderStateMachine.h | 4 +++ dom/media/mediasink/DecodedStream.cpp | 35 +++++++++++++++----------- dom/media/mediasink/DecodedStream.h | 9 ++++--- 6 files changed, 48 insertions(+), 18 deletions(-) diff --git a/dom/media/MediaDecoder.cpp b/dom/media/MediaDecoder.cpp index accdf4c8d50a..79418759cdc1 100644 --- a/dom/media/MediaDecoder.cpp +++ b/dom/media/MediaDecoder.cpp @@ -556,6 +556,8 @@ MediaDecoder::MediaDecoder(MediaDecoderOwner* aOwner) "MediaDecoder::mLogicallySeeking (Canonical)") , mSameOriginMedia(AbstractThread::MainThread(), false, "MediaDecoder::mSameOriginMedia (Canonical)") + , mMediaPrincipalHandle(AbstractThread::MainThread(), PRINCIPAL_HANDLE_NONE, + "MediaDecoder::mMediaPrincipalHandle (Canonical)") , mPlaybackBytesPerSecond(AbstractThread::MainThread(), 0.0, "MediaDecoder::mPlaybackBytesPerSecond (Canonical)") , mPlaybackRateReliable(AbstractThread::MainThread(), true, @@ -1195,6 +1197,8 @@ MediaDecoder::NotifyPrincipalChanged() { MOZ_ASSERT(NS_IsMainThread()); MOZ_ASSERT(!mShuttingDown); + nsCOMPtr newPrincipal = GetCurrentPrincipal(); + mMediaPrincipalHandle = MakePrincipalHandle(newPrincipal); mOwner->NotifyDecoderPrincipalChanged(); } diff --git a/dom/media/MediaDecoder.h b/dom/media/MediaDecoder.h index e85fb0cf9ec8..86f5aa9771dc 100644 --- a/dom/media/MediaDecoder.h +++ b/dom/media/MediaDecoder.h @@ -782,6 +782,10 @@ protected: // passed to MediaStreams when this is true. Canonical mSameOriginMedia; + // An identifier for the principal of the media. Used to track when + // main-thread induced principal changes get reflected on MSG thread. + Canonical mMediaPrincipalHandle; + // Estimate of the current playback rate (bytes/second). Canonical mPlaybackBytesPerSecond; @@ -829,6 +833,9 @@ public: AbstractCanonical* CanonicalSameOriginMedia() { return &mSameOriginMedia; } + AbstractCanonical* CanonicalMediaPrincipalHandle() { + return &mMediaPrincipalHandle; + } AbstractCanonical* CanonicalPlaybackBytesPerSecond() { return &mPlaybackBytesPerSecond; } diff --git a/dom/media/MediaDecoderStateMachine.cpp b/dom/media/MediaDecoderStateMachine.cpp index 618c1db95d67..d9e1f0f2bb05 100644 --- a/dom/media/MediaDecoderStateMachine.cpp +++ b/dom/media/MediaDecoderStateMachine.cpp @@ -267,6 +267,8 @@ MediaDecoderStateMachine::MediaDecoderStateMachine(MediaDecoder* aDecoder, "MediaDecoderStateMachine::mPreservesPitch (Mirror)"), mSameOriginMedia(mTaskQueue, false, "MediaDecoderStateMachine::mSameOriginMedia (Mirror)"), + mMediaPrincipalHandle(mTaskQueue, PRINCIPAL_HANDLE_NONE, + "MediaDecoderStateMachine::mMediaPrincipalHandle (Mirror)"), mPlaybackBytesPerSecond(mTaskQueue, 0.0, "MediaDecoderStateMachine::mPlaybackBytesPerSecond (Mirror)"), mPlaybackRateReliable(mTaskQueue, true, @@ -355,6 +357,7 @@ MediaDecoderStateMachine::InitializationTask(MediaDecoder* aDecoder) mLogicalPlaybackRate.Connect(aDecoder->CanonicalPlaybackRate()); mPreservesPitch.Connect(aDecoder->CanonicalPreservesPitch()); mSameOriginMedia.Connect(aDecoder->CanonicalSameOriginMedia()); + mMediaPrincipalHandle.Connect(aDecoder->CanonicalMediaPrincipalHandle()); mPlaybackBytesPerSecond.Connect(aDecoder->CanonicalPlaybackBytesPerSecond()); mPlaybackRateReliable.Connect(aDecoder->CanonicalPlaybackRateReliable()); mDecoderPosition.Connect(aDecoder->CanonicalDecoderPosition()); @@ -394,7 +397,8 @@ MediaDecoderStateMachine::CreateMediaSink(bool aAudioCaptured) { RefPtr audioSink = aAudioCaptured ? new DecodedStream(mTaskQueue, mAudioQueue, mVideoQueue, - mOutputStreamManager, mSameOriginMedia.Ref()) + mOutputStreamManager, mSameOriginMedia.Ref(), + mMediaPrincipalHandle.Ref()) : CreateAudioSink(); RefPtr mediaSink = @@ -2154,6 +2158,7 @@ MediaDecoderStateMachine::FinishShutdown() mLogicalPlaybackRate.DisconnectIfConnected(); mPreservesPitch.DisconnectIfConnected(); mSameOriginMedia.DisconnectIfConnected(); + mMediaPrincipalHandle.DisconnectIfConnected(); mPlaybackBytesPerSecond.DisconnectIfConnected(); mPlaybackRateReliable.DisconnectIfConnected(); mDecoderPosition.DisconnectIfConnected(); diff --git a/dom/media/MediaDecoderStateMachine.h b/dom/media/MediaDecoderStateMachine.h index 14f349e9410a..d4bb3c936a46 100644 --- a/dom/media/MediaDecoderStateMachine.h +++ b/dom/media/MediaDecoderStateMachine.h @@ -1087,6 +1087,10 @@ private: // passed to MediaStreams when this is true. Mirror mSameOriginMedia; + // An identifier for the principal of the media. Used to track when + // main-thread induced principal changes get reflected on MSG thread. + Mirror mMediaPrincipalHandle; + // Estimate of the current playback rate (bytes/second). Mirror mPlaybackBytesPerSecond; diff --git a/dom/media/mediasink/DecodedStream.cpp b/dom/media/mediasink/DecodedStream.cpp index 58b5c84b3628..73536719c658 100644 --- a/dom/media/mediasink/DecodedStream.cpp +++ b/dom/media/mediasink/DecodedStream.cpp @@ -211,11 +211,13 @@ DecodedStream::DecodedStream(AbstractThread* aOwnerThread, MediaQueue& aAudioQueue, MediaQueue& aVideoQueue, OutputStreamManager* aOutputStreamManager, - const bool& aSameOrigin) + const bool& aSameOrigin, + const PrincipalHandle& aPrincipalHandle) : mOwnerThread(aOwnerThread) , mOutputStreamManager(aOutputStreamManager) , mPlaying(false) , mSameOrigin(aSameOrigin) + , mPrincipalHandle(aPrincipalHandle) , mAudioQueue(aAudioQueue) , mVideoQueue(aVideoQueue) { @@ -401,7 +403,8 @@ DecodedStream::SetPreservesPitch(bool aPreservesPitch) static void SendStreamAudio(DecodedStreamData* aStream, int64_t aStartTime, - MediaData* aData, AudioSegment* aOutput, uint32_t aRate) + MediaData* aData, AudioSegment* aOutput, uint32_t aRate, + const PrincipalHandle& aPrincipalHandle) { // The amount of audio frames that is used to fuzz rounding errors. static const int64_t AUDIO_FUZZ_FRAMES = 1; @@ -440,14 +443,15 @@ SendStreamAudio(DecodedStreamData* aStream, int64_t aStartTime, for (uint32_t i = 0; i < audio->mChannels; ++i) { channels.AppendElement(bufferData + i * audio->mFrames); } - aOutput->AppendFrames(buffer.forget(), channels, audio->mFrames, PRINCIPAL_HANDLE_NONE /* Fixed in later patch */); + aOutput->AppendFrames(buffer.forget(), channels, audio->mFrames, aPrincipalHandle); aStream->mAudioFramesWritten += audio->mFrames; aStream->mNextAudioTime = audio->GetEndTime(); } void -DecodedStream::SendAudio(double aVolume, bool aIsSameOrigin) +DecodedStream::SendAudio(double aVolume, bool aIsSameOrigin, + const PrincipalHandle& aPrincipalHandle) { AssertOwnerThread(); @@ -465,7 +469,8 @@ DecodedStream::SendAudio(double aVolume, bool aIsSameOrigin) // is ref-counted. mAudioQueue.GetElementsAfter(mData->mNextAudioTime, &audio); for (uint32_t i = 0; i < audio.Length(); ++i) { - SendStreamAudio(mData.get(), mStartTime.ref(), audio[i], &output, rate); + SendStreamAudio(mData.get(), mStartTime.ref(), audio[i], &output, rate, + aPrincipalHandle); } output.ApplyVolume(aVolume); @@ -493,13 +498,14 @@ WriteVideoToMediaStream(MediaStream* aStream, int64_t aEndMicroseconds, int64_t aStartMicroseconds, const mozilla::gfx::IntSize& aIntrinsicSize, - VideoSegment* aOutput) + VideoSegment* aOutput, + const PrincipalHandle& aPrincipalHandle) { RefPtr image = aImage; StreamTime duration = aStream->MicrosecondsToStreamTimeRoundDown(aEndMicroseconds) - aStream->MicrosecondsToStreamTimeRoundDown(aStartMicroseconds); - aOutput->AppendFrame(image.forget(), duration, aIntrinsicSize, PRINCIPAL_HANDLE_NONE /* Fixed in later patch */); + aOutput->AppendFrame(image.forget(), duration, aIntrinsicSize, aPrincipalHandle); } static bool @@ -514,7 +520,7 @@ ZeroDurationAtLastChunk(VideoSegment& aInput) } void -DecodedStream::SendVideo(bool aIsSameOrigin) +DecodedStream::SendVideo(bool aIsSameOrigin, const PrincipalHandle& aPrincipalHandle) { AssertOwnerThread(); @@ -545,13 +551,14 @@ DecodedStream::SendVideo(bool aIsSameOrigin) // and capture happens at 15 sec, we'll have to append a black frame // that is 15 sec long. WriteVideoToMediaStream(sourceStream, mData->mLastVideoImage, v->mTime, - mData->mNextVideoTime, mData->mLastVideoImageDisplaySize, &output); + mData->mNextVideoTime, mData->mLastVideoImageDisplaySize, &output, + aPrincipalHandle); mData->mNextVideoTime = v->mTime; } if (mData->mNextVideoTime < v->GetEndTime()) { - WriteVideoToMediaStream(sourceStream, v->mImage, - v->GetEndTime(), mData->mNextVideoTime, v->mDisplay, &output); + WriteVideoToMediaStream(sourceStream, v->mImage, v->GetEndTime(), + mData->mNextVideoTime, v->mDisplay, &output, aPrincipalHandle); mData->mNextVideoTime = v->GetEndTime(); mData->mLastVideoImage = v->mImage; mData->mLastVideoImageDisplaySize = v->mDisplay; @@ -578,7 +585,7 @@ DecodedStream::SendVideo(bool aIsSameOrigin) int64_t deviation_usec = sourceStream->StreamTimeToMicroseconds(1); WriteVideoToMediaStream(sourceStream, mData->mLastVideoImage, mData->mNextVideoTime + deviation_usec, mData->mNextVideoTime, - mData->mLastVideoImageDisplaySize, &endSegment); + mData->mLastVideoImageDisplaySize, &endSegment, aPrincipalHandle); mData->mNextVideoTime += deviation_usec; MOZ_ASSERT(endSegment.GetDuration() > 0); if (!aIsSameOrigin) { @@ -631,8 +638,8 @@ DecodedStream::SendData() return; } - SendAudio(mParams.mVolume, mSameOrigin); - SendVideo(mSameOrigin); + SendAudio(mParams.mVolume, mSameOrigin, mPrincipalHandle); + SendVideo(mSameOrigin, mPrincipalHandle); AdvanceTracks(); bool finished = (!mInfo.HasAudio() || mAudioQueue.IsFinished()) && diff --git a/dom/media/mediasink/DecodedStream.h b/dom/media/mediasink/DecodedStream.h index 94820addc923..c13a5ad5df11 100644 --- a/dom/media/mediasink/DecodedStream.h +++ b/dom/media/mediasink/DecodedStream.h @@ -37,7 +37,8 @@ public: MediaQueue& aAudioQueue, MediaQueue& aVideoQueue, OutputStreamManager* aOutputStreamManager, - const bool& aSameOrigin); + const bool& aSameOrigin, + const PrincipalHandle& aPrincipalHandle); // MediaSink functions. const PlaybackParams& GetPlaybackParams() const override; @@ -68,8 +69,8 @@ protected: private: void DestroyData(UniquePtr aData); void AdvanceTracks(); - void SendAudio(double aVolume, bool aIsSameOrigin); - void SendVideo(bool aIsSameOrigin); + void SendAudio(double aVolume, bool aIsSameOrigin, const PrincipalHandle& aPrincipalHandle); + void SendVideo(bool aIsSameOrigin, const PrincipalHandle& aPrincipalHandle); void SendData(); void AssertOwnerThread() const { @@ -95,6 +96,8 @@ private: bool mPlaying; const bool& mSameOrigin; // valid until Shutdown() is called. + const PrincipalHandle& mPrincipalHandle; // valid until Shutdown() is called. + PlaybackParams mParams; Maybe mStartTime;