This is an archive of the discontinued Mercurial Phabricator instance.

Differential D6029

Bug 1477205 - Remove the exception when a node is created after closing the AudioContext. r?padenot
Needs RevisionPublic

Authored by vmillet on Feb 27 2019, 5:47 AM.

Details

Reviewers
baymax
Group Reviewers
hg-reviewers

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

vmillet created this revision.Feb 27 2019, 5:47 AM
marmoute added a subscriber: marmoute.Feb 27 2019, 7:24 AM

Hi Valentin,

It looks like you are not using the right Phabricator instance. This one is dedicated to the Mercurial projet, not Firefox.

baymax requested changes to this revision.Jan 24 2020, 12:32 PM

There seems to have been no activities on this Diff for the past 3 Months.

By policy, we are automatically moving it out of the need-review state.

Please, move it back to need-review without hesitation if this diff should still be discussed.

:baymax:need-review-idle:

This revision now requires changes to proceed.Jan 24 2020, 12:32 PM

Revision Contents
Changeset List

Diff 14252

dom/media/webaudio/AnalyserNode.cpp

} }
uint32_t mChunksToProcess = 0; uint32_t mChunksToProcess = 0;
}; };
/* static */ already_AddRefed<AnalyserNode> AnalyserNode::Create( /* static */ already_AddRefed<AnalyserNode> AnalyserNode::Create(
AudioContext& aAudioContext, const AnalyserOptions& aOptions, AudioContext& aAudioContext, const AnalyserOptions& aOptions,
ErrorResult& aRv) { ErrorResult& aRv) {
if (aAudioContext.CheckClosed(aRv)) {
return nullptr;
}
RefPtr<AnalyserNode> analyserNode = new AnalyserNode(&aAudioContext); RefPtr<AnalyserNode> analyserNode = new AnalyserNode(&aAudioContext);
analyserNode->Initialize(aOptions, aRv); analyserNode->Initialize(aOptions, aRv);
if (NS_WARN_IF(aRv.Failed())) { if (NS_WARN_IF(aRv.Failed())) {
return nullptr; return nullptr;
} }

dom/media/webaudio/AudioBufferSourceNode.cpp

engine->SetSourceStream(mStream); engine->SetSourceStream(mStream);
mStream->AddMainThreadListener(this); mStream->AddMainThreadListener(this);
} }
/* static */ already_AddRefed<AudioBufferSourceNode> /* static */ already_AddRefed<AudioBufferSourceNode>
AudioBufferSourceNode::Create(JSContext* aCx, AudioContext& aAudioContext, AudioBufferSourceNode::Create(JSContext* aCx, AudioContext& aAudioContext,
const AudioBufferSourceOptions& aOptions, const AudioBufferSourceOptions& aOptions,
ErrorResult& aRv) { ErrorResult& aRv) {
if (aAudioContext.CheckClosed(aRv)) {
return nullptr;
}
RefPtr<AudioBufferSourceNode> audioNode = RefPtr<AudioBufferSourceNode> audioNode =
new AudioBufferSourceNode(&aAudioContext); new AudioBufferSourceNode(&aAudioContext);
if (aOptions.mBuffer.WasPassed()) { if (aOptions.mBuffer.WasPassed()) {
MOZ_ASSERT(aCx); MOZ_ASSERT(aCx);
audioNode->SetBuffer(aCx, aOptions.mBuffer.Value()); audioNode->SetBuffer(aCx, aOptions.mBuffer.Value());
} }

dom/media/webaudio/AudioContext.h

void RegisterNode(AudioNode* aNode); void RegisterNode(AudioNode* aNode);
void UnregisterNode(AudioNode* aNode); void UnregisterNode(AudioNode* aNode);
void OnStateChanged(void* aPromise, AudioContextState aNewState); void OnStateChanged(void* aPromise, AudioContextState aNewState);
BasicWaveFormCache* GetBasicWaveFormCache(); BasicWaveFormCache* GetBasicWaveFormCache();
bool CheckClosed(ErrorResult& aRv);
void Dispatch(already_AddRefed<nsIRunnable>&& aRunnable); void Dispatch(already_AddRefed<nsIRunnable>&& aRunnable);
private: private:
void DisconnectFromWindow(); void DisconnectFromWindow();
void RemoveFromDecodeQueue(WebAudioDecodeJob* aDecodeJob); void RemoveFromDecodeQueue(WebAudioDecodeJob* aDecodeJob);
void ShutdownDecoder(); void ShutdownDecoder();
size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const; size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;

dom/media/webaudio/AudioContext.cpp

RefPtr<AudioContext> object = RefPtr<AudioContext> object =
new AudioContext(window, true, aNumberOfChannels, aLength, aSampleRate); new AudioContext(window, true, aNumberOfChannels, aLength, aSampleRate);
RegisterWeakMemoryReporter(object); RegisterWeakMemoryReporter(object);
return object.forget(); return object.forget();
} }
bool AudioContext::CheckClosed(ErrorResult& aRv) {
if (mAudioContextState == AudioContextState::Closed || mIsShutDown ||
mIsDisconnecting) {
aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
return true;
}
return false;
}
already_AddRefed<AudioBufferSourceNode> AudioContext::CreateBufferSource( already_AddRefed<AudioBufferSourceNode> AudioContext::CreateBufferSource(
ErrorResult& aRv) { ErrorResult& aRv) {
return AudioBufferSourceNode::Create(nullptr, *this, return AudioBufferSourceNode::Create(nullptr, *this,
AudioBufferSourceOptions(), aRv); AudioBufferSourceOptions(), aRv);
} }
already_AddRefed<ConstantSourceNode> AudioContext::CreateConstantSource( already_AddRefed<ConstantSourceNode> AudioContext::CreateConstantSource(
ErrorResult& aRv) { ErrorResult& aRv) {
if (CheckClosed(aRv)) {
return nullptr;
}
RefPtr<ConstantSourceNode> constantSourceNode = new ConstantSourceNode(this); RefPtr<ConstantSourceNode> constantSourceNode = new ConstantSourceNode(this);
return constantSourceNode.forget(); return constantSourceNode.forget();
} }
already_AddRefed<AudioBuffer> AudioContext::CreateBuffer( already_AddRefed<AudioBuffer> AudioContext::CreateBuffer(
uint32_t aNumberOfChannels, uint32_t aLength, float aSampleRate, uint32_t aNumberOfChannels, uint32_t aLength, float aSampleRate,
ErrorResult& aRv) { ErrorResult& aRv) {
if ((aNumberOfInputChannels == 0 && aNumberOfOutputChannels == 0) || if ((aNumberOfInputChannels == 0 && aNumberOfOutputChannels == 0) ||
aNumberOfInputChannels > WebAudioUtils::MaxChannelCount || aNumberOfInputChannels > WebAudioUtils::MaxChannelCount ||
aNumberOfOutputChannels > WebAudioUtils::MaxChannelCount || aNumberOfOutputChannels > WebAudioUtils::MaxChannelCount ||
!IsValidBufferSize(aBufferSize)) { !IsValidBufferSize(aBufferSize)) {
aRv.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR); aRv.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
return nullptr; return nullptr;
} }
if (CheckClosed(aRv)) {
return nullptr;
}
RefPtr<ScriptProcessorNode> scriptProcessor = new ScriptProcessorNode( RefPtr<ScriptProcessorNode> scriptProcessor = new ScriptProcessorNode(
this, aBufferSize, aNumberOfInputChannels, aNumberOfOutputChannels); this, aBufferSize, aNumberOfInputChannels, aNumberOfOutputChannels);
return scriptProcessor.forget(); return scriptProcessor.forget();
} }
already_AddRefed<AnalyserNode> AudioContext::CreateAnalyser(ErrorResult& aRv) { already_AddRefed<AnalyserNode> AudioContext::CreateAnalyser(ErrorResult& aRv) {
return AnalyserNode::Create(*this, AnalyserOptions(), aRv); return AnalyserNode::Create(*this, AnalyserOptions(), aRv);
} }

dom/media/webaudio/AudioWorkletNode.cpp

: AudioNode(aAudioContext, 2, ChannelCountMode::Max, : AudioNode(aAudioContext, 2, ChannelCountMode::Max,
ChannelInterpretation::Speakers), ChannelInterpretation::Speakers),
mNodeName(aName) {} mNodeName(aName) {}
/* static */ already_AddRefed<AudioWorkletNode> AudioWorkletNode::Constructor( /* static */ already_AddRefed<AudioWorkletNode> AudioWorkletNode::Constructor(
const GlobalObject& aGlobal, AudioContext& aAudioContext, const GlobalObject& aGlobal, AudioContext& aAudioContext,
const nsAString& aName, const AudioWorkletNodeOptions& aOptions, const nsAString& aName, const AudioWorkletNodeOptions& aOptions,
ErrorResult& aRv) { ErrorResult& aRv) {
if (aAudioContext.CheckClosed(aRv)) {
return nullptr;
}
if (aOptions.mNumberOfInputs == 0 && aOptions.mNumberOfOutputs == 0) { if (aOptions.mNumberOfInputs == 0 && aOptions.mNumberOfOutputs == 0) {
aRv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR); aRv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
return nullptr; return nullptr;
} }
if (aOptions.mOutputChannelCount.WasPassed()) { if (aOptions.mOutputChannelCount.WasPassed()) {
if (aOptions.mOutputChannelCount.Value().Length() != if (aOptions.mOutputChannelCount.Value().Length() !=

dom/media/webaudio/BiquadFilterNode.cpp

new BiquadFilterNodeEngine(this, aContext->Destination(), windowID); new BiquadFilterNodeEngine(this, aContext->Destination(), windowID);
mStream = AudioNodeStream::Create( mStream = AudioNodeStream::Create(
aContext, engine, AudioNodeStream::NO_STREAM_FLAGS, aContext->Graph()); aContext, engine, AudioNodeStream::NO_STREAM_FLAGS, aContext->Graph());
} }
/* static */ already_AddRefed<BiquadFilterNode> BiquadFilterNode::Create( /* static */ already_AddRefed<BiquadFilterNode> BiquadFilterNode::Create(
AudioContext& aAudioContext, const BiquadFilterOptions& aOptions, AudioContext& aAudioContext, const BiquadFilterOptions& aOptions,
ErrorResult& aRv) { ErrorResult& aRv) {
if (aAudioContext.CheckClosed(aRv)) {
return nullptr;
}
RefPtr<BiquadFilterNode> audioNode = new BiquadFilterNode(&aAudioContext); RefPtr<BiquadFilterNode> audioNode = new BiquadFilterNode(&aAudioContext);
audioNode->Initialize(aOptions, aRv); audioNode->Initialize(aOptions, aRv);
if (NS_WARN_IF(aRv.Failed())) { if (NS_WARN_IF(aRv.Failed())) {
return nullptr; return nullptr;
} }

dom/media/webaudio/ChannelMergerNode.cpp

mStream = AudioNodeStream::Create(aContext, new ChannelMergerNodeEngine(this), mStream = AudioNodeStream::Create(aContext, new ChannelMergerNodeEngine(this),
AudioNodeStream::NO_STREAM_FLAGS, AudioNodeStream::NO_STREAM_FLAGS,
aContext->Graph()); aContext->Graph());
} }
/* static */ already_AddRefed<ChannelMergerNode> ChannelMergerNode::Create( /* static */ already_AddRefed<ChannelMergerNode> ChannelMergerNode::Create(
AudioContext& aAudioContext, const ChannelMergerOptions& aOptions, AudioContext& aAudioContext, const ChannelMergerOptions& aOptions,
ErrorResult& aRv) { ErrorResult& aRv) {
if (aAudioContext.CheckClosed(aRv)) {
return nullptr;
}
if (aOptions.mNumberOfInputs == 0 || if (aOptions.mNumberOfInputs == 0 ||
aOptions.mNumberOfInputs > WebAudioUtils::MaxChannelCount) { aOptions.mNumberOfInputs > WebAudioUtils::MaxChannelCount) {
aRv.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR); aRv.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
return nullptr; return nullptr;
} }
RefPtr<ChannelMergerNode> audioNode = RefPtr<ChannelMergerNode> audioNode =

dom/media/webaudio/ChannelSplitterNode.cpp

mStream = AudioNodeStream::Create( mStream = AudioNodeStream::Create(
aContext, new ChannelSplitterNodeEngine(this), aContext, new ChannelSplitterNodeEngine(this),
AudioNodeStream::NO_STREAM_FLAGS, aContext->Graph()); AudioNodeStream::NO_STREAM_FLAGS, aContext->Graph());
} }
/* static */ already_AddRefed<ChannelSplitterNode> ChannelSplitterNode::Create( /* static */ already_AddRefed<ChannelSplitterNode> ChannelSplitterNode::Create(
AudioContext& aAudioContext, const ChannelSplitterOptions& aOptions, AudioContext& aAudioContext, const ChannelSplitterOptions& aOptions,
ErrorResult& aRv) { ErrorResult& aRv) {
if (aAudioContext.CheckClosed(aRv)) {
return nullptr;
}
if (aOptions.mNumberOfOutputs == 0 || if (aOptions.mNumberOfOutputs == 0 ||
aOptions.mNumberOfOutputs > WebAudioUtils::MaxChannelCount) { aOptions.mNumberOfOutputs > WebAudioUtils::MaxChannelCount) {
aRv.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR); aRv.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
return nullptr; return nullptr;
} }
RefPtr<ChannelSplitterNode> audioNode = RefPtr<ChannelSplitterNode> audioNode =

dom/media/webaudio/ConvolverNode.cpp

new ConvolverNodeEngine(this, mNormalize, windowID); new ConvolverNodeEngine(this, mNormalize, windowID);
mStream = AudioNodeStream::Create( mStream = AudioNodeStream::Create(
aContext, engine, AudioNodeStream::NO_STREAM_FLAGS, aContext->Graph()); aContext, engine, AudioNodeStream::NO_STREAM_FLAGS, aContext->Graph());
} }
/* static */ already_AddRefed<ConvolverNode> ConvolverNode::Create( /* static */ already_AddRefed<ConvolverNode> ConvolverNode::Create(
JSContext* aCx, AudioContext& aAudioContext, JSContext* aCx, AudioContext& aAudioContext,
const ConvolverOptions& aOptions, ErrorResult& aRv) { const ConvolverOptions& aOptions, ErrorResult& aRv) {
if (aAudioContext.CheckClosed(aRv)) {
return nullptr;
}
RefPtr<ConvolverNode> audioNode = new ConvolverNode(&aAudioContext); RefPtr<ConvolverNode> audioNode = new ConvolverNode(&aAudioContext);
audioNode->Initialize(aOptions, aRv); audioNode->Initialize(aOptions, aRv);
if (NS_WARN_IF(aRv.Failed())) { if (NS_WARN_IF(aRv.Failed())) {
return nullptr; return nullptr;
} }

dom/media/webaudio/DelayNode.cpp

this, aContext->Destination(), aContext->SampleRate() * aMaxDelay); this, aContext->Destination(), aContext->SampleRate() * aMaxDelay);
mStream = AudioNodeStream::Create( mStream = AudioNodeStream::Create(
aContext, engine, AudioNodeStream::NO_STREAM_FLAGS, aContext->Graph()); aContext, engine, AudioNodeStream::NO_STREAM_FLAGS, aContext->Graph());
} }
/* static */ already_AddRefed<DelayNode> DelayNode::Create( /* static */ already_AddRefed<DelayNode> DelayNode::Create(
AudioContext& aAudioContext, const DelayOptions& aOptions, AudioContext& aAudioContext, const DelayOptions& aOptions,
ErrorResult& aRv) { ErrorResult& aRv) {
if (aAudioContext.CheckClosed(aRv)) {
return nullptr;
}
if (aOptions.mMaxDelayTime <= 0. || aOptions.mMaxDelayTime >= 180.) { if (aOptions.mMaxDelayTime <= 0. || aOptions.mMaxDelayTime >= 180.) {
aRv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR); aRv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
return nullptr; return nullptr;
} }
RefPtr<DelayNode> audioNode = RefPtr<DelayNode> audioNode =
new DelayNode(&aAudioContext, aOptions.mMaxDelayTime); new DelayNode(&aAudioContext, aOptions.mMaxDelayTime);

dom/media/webaudio/DynamicsCompressorNode.cpp

mStream = AudioNodeStream::Create( mStream = AudioNodeStream::Create(
aContext, engine, AudioNodeStream::NO_STREAM_FLAGS, aContext->Graph()); aContext, engine, AudioNodeStream::NO_STREAM_FLAGS, aContext->Graph());
} }
/* static */ already_AddRefed<DynamicsCompressorNode> /* static */ already_AddRefed<DynamicsCompressorNode>
DynamicsCompressorNode::Create(AudioContext& aAudioContext, DynamicsCompressorNode::Create(AudioContext& aAudioContext,
const DynamicsCompressorOptions& aOptions, const DynamicsCompressorOptions& aOptions,
ErrorResult& aRv) { ErrorResult& aRv) {
if (aAudioContext.CheckClosed(aRv)) {
return nullptr;
}
RefPtr<DynamicsCompressorNode> audioNode = RefPtr<DynamicsCompressorNode> audioNode =
new DynamicsCompressorNode(&aAudioContext); new DynamicsCompressorNode(&aAudioContext);
audioNode->Initialize(aOptions, aRv); audioNode->Initialize(aOptions, aRv);
if (NS_WARN_IF(aRv.Failed())) { if (NS_WARN_IF(aRv.Failed())) {
return nullptr; return nullptr;
} }

dom/media/webaudio/GainNode.cpp

GainNodeEngine* engine = new GainNodeEngine(this, aContext->Destination()); GainNodeEngine* engine = new GainNodeEngine(this, aContext->Destination());
mStream = AudioNodeStream::Create( mStream = AudioNodeStream::Create(
aContext, engine, AudioNodeStream::NO_STREAM_FLAGS, aContext->Graph()); aContext, engine, AudioNodeStream::NO_STREAM_FLAGS, aContext->Graph());
} }
/* static */ already_AddRefed<GainNode> GainNode::Create( /* static */ already_AddRefed<GainNode> GainNode::Create(
AudioContext& aAudioContext, const GainOptions& aOptions, AudioContext& aAudioContext, const GainOptions& aOptions,
ErrorResult& aRv) { ErrorResult& aRv) {
if (aAudioContext.CheckClosed(aRv)) {
return nullptr;
}
RefPtr<GainNode> audioNode = new GainNode(&aAudioContext); RefPtr<GainNode> audioNode = new GainNode(&aAudioContext);
audioNode->Initialize(aOptions, aRv); audioNode->Initialize(aOptions, aRv);
if (NS_WARN_IF(aRv.Failed())) { if (NS_WARN_IF(aRv.Failed())) {
return nullptr; return nullptr;
} }

dom/media/webaudio/IIRFilterNode.cpp

this, aContext->Destination(), mFeedforward, mFeedback, windowID); this, aContext->Destination(), mFeedforward, mFeedback, windowID);
mStream = AudioNodeStream::Create( mStream = AudioNodeStream::Create(
aContext, engine, AudioNodeStream::NO_STREAM_FLAGS, aContext->Graph()); aContext, engine, AudioNodeStream::NO_STREAM_FLAGS, aContext->Graph());
} }
/* static */ already_AddRefed<IIRFilterNode> IIRFilterNode::Create( /* static */ already_AddRefed<IIRFilterNode> IIRFilterNode::Create(
AudioContext& aAudioContext, const IIRFilterOptions& aOptions, AudioContext& aAudioContext, const IIRFilterOptions& aOptions,
ErrorResult& aRv) { ErrorResult& aRv) {
if (aAudioContext.CheckClosed(aRv)) {
return nullptr;
}
if (aOptions.mFeedforward.Length() == 0 || if (aOptions.mFeedforward.Length() == 0 ||
aOptions.mFeedforward.Length() > 20) { aOptions.mFeedforward.Length() > 20) {
aRv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR); aRv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
return nullptr; return nullptr;
} }
if (aOptions.mFeedback.Length() == 0 || aOptions.mFeedback.Length() > 20) { if (aOptions.mFeedback.Length() == 0 || aOptions.mFeedback.Length() > 20) {

dom/media/webaudio/MediaElementAudioSourceNode.cpp

MediaElementAudioSourceNode::Create( MediaElementAudioSourceNode::Create(
AudioContext& aAudioContext, const MediaElementAudioSourceOptions& aOptions, AudioContext& aAudioContext, const MediaElementAudioSourceOptions& aOptions,
ErrorResult& aRv) { ErrorResult& aRv) {
if (aAudioContext.IsOffline()) { if (aAudioContext.IsOffline()) {
aRv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR); aRv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
return nullptr; return nullptr;
} }
if (aAudioContext.CheckClosed(aRv)) {
return nullptr;
}
RefPtr<MediaElementAudioSourceNode> node = RefPtr<MediaElementAudioSourceNode> node =
new MediaElementAudioSourceNode(&aAudioContext); new MediaElementAudioSourceNode(&aAudioContext);
RefPtr<DOMMediaStream> stream = aOptions.mMediaElement->CaptureAudio( RefPtr<DOMMediaStream> stream = aOptions.mMediaElement->CaptureAudio(
aRv, aAudioContext.Destination()->Stream()->Graph()); aRv, aAudioContext.Destination()->Stream()->Graph());
if (aRv.Failed()) { if (aRv.Failed()) {
return nullptr; return nullptr;
} }

dom/media/webaudio/MediaStreamAudioDestinationNode.cpp

MediaStreamAudioDestinationNode::Create(AudioContext& aAudioContext, MediaStreamAudioDestinationNode::Create(AudioContext& aAudioContext,
const AudioNodeOptions& aOptions, const AudioNodeOptions& aOptions,
ErrorResult& aRv) { ErrorResult& aRv) {
if (aAudioContext.IsOffline()) { if (aAudioContext.IsOffline()) {
aRv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR); aRv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
return nullptr; return nullptr;
} }
if (aAudioContext.CheckClosed(aRv)) {
return nullptr;
}
RefPtr<MediaStreamAudioDestinationNode> audioNode = RefPtr<MediaStreamAudioDestinationNode> audioNode =
new MediaStreamAudioDestinationNode(&aAudioContext); new MediaStreamAudioDestinationNode(&aAudioContext);
audioNode->Initialize(aOptions, aRv); audioNode->Initialize(aOptions, aRv);
if (NS_WARN_IF(aRv.Failed())) { if (NS_WARN_IF(aRv.Failed())) {
return nullptr; return nullptr;
} }

dom/media/webaudio/MediaStreamAudioSourceNode.cpp

MediaStreamAudioSourceNode::Create( MediaStreamAudioSourceNode::Create(
AudioContext& aAudioContext, const MediaStreamAudioSourceOptions& aOptions, AudioContext& aAudioContext, const MediaStreamAudioSourceOptions& aOptions,
ErrorResult& aRv) { ErrorResult& aRv) {
if (aAudioContext.IsOffline()) { if (aAudioContext.IsOffline()) {
aRv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR); aRv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
return nullptr; return nullptr;
} }
if (aAudioContext.CheckClosed(aRv)) {
return nullptr;
}
if (aAudioContext.Graph() != if (aAudioContext.Graph() !=
aOptions.mMediaStream->GetPlaybackStream()->Graph()) { aOptions.mMediaStream->GetPlaybackStream()->Graph()) {
nsCOMPtr<nsPIDOMWindowInner> pWindow = aAudioContext.GetParentObject(); nsCOMPtr<nsPIDOMWindowInner> pWindow = aAudioContext.GetParentObject();
Document* document = pWindow ? pWindow->GetExtantDoc() : nullptr; Document* document = pWindow ? pWindow->GetExtantDoc() : nullptr;
nsContentUtils::ReportToConsole(nsIScriptError::warningFlag, nsContentUtils::ReportToConsole(nsIScriptError::warningFlag,
NS_LITERAL_CSTRING("Web Audio"), document, NS_LITERAL_CSTRING("Web Audio"), document,
nsContentUtils::eDOM_PROPERTIES, nsContentUtils::eDOM_PROPERTIES,
"MediaStreamAudioSourceNodeDifferentRate"); "MediaStreamAudioSourceNodeDifferentRate");

dom/media/webaudio/OscillatorNode.cpp

aContext->Graph()); aContext->Graph());
engine->SetSourceStream(mStream); engine->SetSourceStream(mStream);
mStream->AddMainThreadListener(this); mStream->AddMainThreadListener(this);
} }
/* static */ already_AddRefed<OscillatorNode> OscillatorNode::Create( /* static */ already_AddRefed<OscillatorNode> OscillatorNode::Create(
AudioContext& aAudioContext, const OscillatorOptions& aOptions, AudioContext& aAudioContext, const OscillatorOptions& aOptions,
ErrorResult& aRv) { ErrorResult& aRv) {
if (aAudioContext.CheckClosed(aRv)) {
return nullptr;
}
RefPtr<OscillatorNode> audioNode = new OscillatorNode(&aAudioContext); RefPtr<OscillatorNode> audioNode = new OscillatorNode(&aAudioContext);
audioNode->Initialize(aOptions, aRv); audioNode->Initialize(aOptions, aRv);
if (NS_WARN_IF(aRv.Failed())) { if (NS_WARN_IF(aRv.Failed())) {
return nullptr; return nullptr;
} }

dom/media/webaudio/PannerNode.cpp

new PannerNodeEngine(this, aContext->Destination(), new PannerNodeEngine(this, aContext->Destination(),
aContext->Listener()->Engine()), aContext->Listener()->Engine()),
AudioNodeStream::NO_STREAM_FLAGS, aContext->Graph()); AudioNodeStream::NO_STREAM_FLAGS, aContext->Graph());
} }
/* static */ already_AddRefed<PannerNode> PannerNode::Create( /* static */ already_AddRefed<PannerNode> PannerNode::Create(
AudioContext& aAudioContext, const PannerOptions& aOptions, AudioContext& aAudioContext, const PannerOptions& aOptions,
ErrorResult& aRv) { ErrorResult& aRv) {
if (aAudioContext.CheckClosed(aRv)) {
return nullptr;
}
RefPtr<PannerNode> audioNode = new PannerNode(&aAudioContext); RefPtr<PannerNode> audioNode = new PannerNode(&aAudioContext);
audioNode->Initialize(aOptions, aRv); audioNode->Initialize(aOptions, aRv);
if (NS_WARN_IF(aRv.Failed())) { if (NS_WARN_IF(aRv.Failed())) {
return nullptr; return nullptr;
} }

dom/media/webaudio/StereoPannerNode.cpp

new StereoPannerNodeEngine(this, aContext->Destination()); new StereoPannerNodeEngine(this, aContext->Destination());
mStream = AudioNodeStream::Create( mStream = AudioNodeStream::Create(
aContext, engine, AudioNodeStream::NO_STREAM_FLAGS, aContext->Graph()); aContext, engine, AudioNodeStream::NO_STREAM_FLAGS, aContext->Graph());
} }
/* static */ already_AddRefed<StereoPannerNode> StereoPannerNode::Create( /* static */ already_AddRefed<StereoPannerNode> StereoPannerNode::Create(
AudioContext& aAudioContext, const StereoPannerOptions& aOptions, AudioContext& aAudioContext, const StereoPannerOptions& aOptions,
ErrorResult& aRv) { ErrorResult& aRv) {
if (aAudioContext.CheckClosed(aRv)) {
return nullptr;
}
RefPtr<StereoPannerNode> audioNode = new StereoPannerNode(&aAudioContext); RefPtr<StereoPannerNode> audioNode = new StereoPannerNode(&aAudioContext);
audioNode->Initialize(aOptions, aRv); audioNode->Initialize(aOptions, aRv);
if (NS_WARN_IF(aRv.Failed())) { if (NS_WARN_IF(aRv.Failed())) {
return nullptr; return nullptr;
} }

dom/media/webaudio/WaveShaperNode.cpp

WaveShaperNodeEngine* engine = new WaveShaperNodeEngine(this); WaveShaperNodeEngine* engine = new WaveShaperNodeEngine(this);
mStream = AudioNodeStream::Create( mStream = AudioNodeStream::Create(
aContext, engine, AudioNodeStream::NO_STREAM_FLAGS, aContext->Graph()); aContext, engine, AudioNodeStream::NO_STREAM_FLAGS, aContext->Graph());
} }
/* static */ already_AddRefed<WaveShaperNode> WaveShaperNode::Create( /* static */ already_AddRefed<WaveShaperNode> WaveShaperNode::Create(
AudioContext& aAudioContext, const WaveShaperOptions& aOptions, AudioContext& aAudioContext, const WaveShaperOptions& aOptions,
ErrorResult& aRv) { ErrorResult& aRv) {
if (aAudioContext.CheckClosed(aRv)) {
return nullptr;
}
RefPtr<WaveShaperNode> audioNode = new WaveShaperNode(&aAudioContext); RefPtr<WaveShaperNode> audioNode = new WaveShaperNode(&aAudioContext);
audioNode->Initialize(aOptions, aRv); audioNode->Initialize(aOptions, aRv);
if (NS_WARN_IF(aRv.Failed())) { if (NS_WARN_IF(aRv.Failed())) {
return nullptr; return nullptr;
} }

dom/media/webaudio/test/test_audioContextSuspendResumeClose.html

args: [new Audio().mozCaptureStream()], args: [new Audio().mozCaptureStream()],
onOfflineAudioContext: false } ].forEach(function(e) { onOfflineAudioContext: false } ].forEach(function(e) {
if (e.onOfflineAudioContext == false && if (e.onOfflineAudioContext == false &&
ctx instanceof OfflineAudioContext) { ctx instanceof OfflineAudioContext) {
return; return;
} }
expectException(function() { expectNoException(function() {
ctx[e.name].apply(ctx, e.args); ctx[e.name].apply(ctx, e.args);
}, DOMException.INVALID_STATE_ERR); }, DOMException.INVALID_STATE_ERR);
}); });
} }
function loadFile(url, callback) { function loadFile(url, callback) {
var xhr = new XMLHttpRequest(); var xhr = new XMLHttpRequest();
xhr.open("GET", url, true); xhr.open("GET", url, true);