Move many calls of lazyInitialize() from AudioContext to AudioNode.

Source/modules/webaudio/AudioContext.cpp

 /*
  * Copyright (C) 2010, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1.  Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 167 matching lines @@
         m_renderingAutomaticPullNodes.resize(m_automaticPullNodes.size());
     ASSERT(!m_renderingAutomaticPullNodes.size());
 }
 
 void AudioContext::lazyInitialize()
 {
     if (!m_isInitialized) {
         // Don't allow the context to initialize a second time after it's already been explicitly uninitialized.
         ASSERT(!m_isAudioThreadFinished);
         if (!m_isAudioThreadFinished) {
+            // Creation of a destination node should not start the audio HW. The
+            // creation of any other AudioNode will initialize the audio HW and start processing
             if (m_destinationNode.get()) {
                 m_destinationNode->initialize();
 
                 if (!isOfflineContext()) {
                     // This starts the audio thread. The destination node's provideInput() method will now be called repeatedly to render audio.
                     // Each time provideInput() is called, a portion of the audio stream is rendered. Let's call this time period a "render quantum".
                     // NOTE: for now default AudioContext does not need an explicit startRendering() call from JavaScript.
                     // We may want to consider requiring it for symmetry with OfflineAudioContext.
                     m_destinationNode->startRendering();
                     ++s_hardwareContextCount;
                 }
 
+                m_isInitialized = true;
             }
-            m_isInitialized = true;
         }
     }
 }
 
 void AudioContext::clear()
 {
     // We have to release our reference to the destination node before the context will ever be deleted since the destination node holds a reference to the context.
     if (m_destinationNode)
         m_destinationNode.clear();
 
@@ skipping 127 matching lines @@
             SyntaxError,
             "invalid ArrayBuffer for audioData.");
         return;
     }
     m_audioDecoder.decodeAsync(audioData, sampleRate(), successCallback, errorCallback);
 }
 
 PassRefPtr<AudioBufferSourceNode> AudioContext::createBufferSource()
 {
     ASSERT(isMainThread());
-    lazyInitialize();
     RefPtr<AudioBufferSourceNode> node = AudioBufferSourceNode::create(this, m_destinationNode->sampleRate());
 
     // Because this is an AudioScheduledSourceNode, the context keeps a reference until it has finished playing.
     // When this happens, AudioScheduledSourceNode::finish() calls AudioContext::notifyNodeFinishedProcessing().
     refNode(node.get());
 
     return node;
 }
 
 PassRefPtr<MediaElementAudioSourceNode> AudioContext::createMediaElementSource(HTMLMediaElement* mediaElement, ExceptionState& exceptionState)
 {
+    ASSERT(isMainThread());
     if (!mediaElement) {
         exceptionState.throwDOMException(
             InvalidStateError,
             "invalid HTMLMedialElement.");
         return nullptr;
     }
 
-    ASSERT(isMainThread());
-    lazyInitialize();
-
     // First check if this media element already has a source node.
     if (mediaElement->audioSourceNode()) {
         exceptionState.throwDOMException(
             InvalidStateError,
             "invalid HTMLMediaElement.");
         return nullptr;
     }
 
     RefPtr<MediaElementAudioSourceNode> node = MediaElementAudioSourceNode::create(this, mediaElement);
 
     mediaElement->setAudioSourceNode(node.get());
 
     refNode(node.get()); // context keeps reference until node is disconnected
     return node;
 }
 
 PassRefPtr<MediaStreamAudioSourceNode> AudioContext::createMediaStreamSource(MediaStream* mediaStream, ExceptionState& exceptionState)
 {
+    ASSERT(isMainThread());
     if (!mediaStream) {
         exceptionState.throwDOMException(
             InvalidStateError,
             "invalid MediaStream source");
         return nullptr;
     }
 
-    ASSERT(isMainThread());
-    lazyInitialize();
-
     MediaStreamTrackVector audioTracks = mediaStream->getAudioTracks();
     if (audioTracks.isEmpty()) {
         exceptionState.throwDOMException(
             InvalidStateError,
             "MediaStream has no audio track");
         return nullptr;
     }
 
     // Use the first audio track in the media stream.
     RefPtr<MediaStreamTrack> audioTrack = audioTracks[0];
@@ skipping 27 matching lines @@
 
 PassRefPtr<ScriptProcessorNode> AudioContext::createScriptProcessor(size_t bufferSize, size_t numberOfInputChannels, ExceptionState& exceptionState)
 {
     // Set number of output channels to stereo by default.
     return createScriptProcessor(bufferSize, numberOfInputChannels, 2, exceptionState);
 }
 
 PassRefPtr<ScriptProcessorNode> AudioContext::createScriptProcessor(size_t bufferSize, size_t numberOfInputChannels, size_t numberOfOutputChannels, ExceptionState& exceptionState)
 {
     ASSERT(isMainThread());
-    lazyInitialize();
     RefPtr<ScriptProcessorNode> node = ScriptProcessorNode::create(this, m_destinationNode->sampleRate(), bufferSize, numberOfInputChannels, numberOfOutputChannels);
 
     if (!node.get()) {
         if (!numberOfInputChannels && !numberOfOutputChannels) {
             exceptionState.throwDOMException(
                 IndexSizeError,
                 "number of input channels and output channels cannot both be zero.");
         } else if (numberOfInputChannels > AudioContext::maxNumberOfChannels()) {
             exceptionState.throwDOMException(
                 IndexSizeError,
@@ skipping 15 matching lines @@
         return nullptr;
     }
 
     refNode(node.get()); // context keeps reference until we stop making javascript rendering callbacks
     return node;
 }
 
 PassRefPtr<BiquadFilterNode> AudioContext::createBiquadFilter()
 {
     ASSERT(isMainThread());
-    lazyInitialize();
     return BiquadFilterNode::create(this, m_destinationNode->sampleRate());
 }
 
 PassRefPtr<WaveShaperNode> AudioContext::createWaveShaper()
 {
     ASSERT(isMainThread());
-    lazyInitialize();
     return WaveShaperNode::create(this);
 }
 
 PassRefPtr<PannerNode> AudioContext::createPanner()
 {
     ASSERT(isMainThread());
-    lazyInitialize();
     return PannerNode::create(this, m_destinationNode->sampleRate());
 }
 
 PassRefPtr<ConvolverNode> AudioContext::createConvolver()
 {
     ASSERT(isMainThread());
-    lazyInitialize();
     return ConvolverNode::create(this, m_destinationNode->sampleRate());
 }
 
 PassRefPtr<DynamicsCompressorNode> AudioContext::createDynamicsCompressor()
 {
     ASSERT(isMainThread());
-    lazyInitialize();
     return DynamicsCompressorNode::create(this, m_destinationNode->sampleRate());
 }
 
 PassRefPtr<AnalyserNode> AudioContext::createAnalyser()
 {
     ASSERT(isMainThread());
-    lazyInitialize();
     return AnalyserNode::create(this, m_destinationNode->sampleRate());
 }
 
 PassRefPtr<GainNode> AudioContext::createGain()
 {
     ASSERT(isMainThread());
-    lazyInitialize();
     return GainNode::create(this, m_destinationNode->sampleRate());
 }
 
 PassRefPtr<DelayNode> AudioContext::createDelay(ExceptionState& exceptionState)
 {
     const double defaultMaxDelayTime = 1;
     return createDelay(defaultMaxDelayTime, exceptionState);
 }
 
 PassRefPtr<DelayNode> AudioContext::createDelay(double maxDelayTime, ExceptionState& exceptionState)
 {
     ASSERT(isMainThread());
-    lazyInitialize();
     RefPtr<DelayNode> node = DelayNode::create(this, m_destinationNode->sampleRate(), maxDelayTime, exceptionState);
     if (exceptionState.hadException())
         return nullptr;
     return node;
 }
 
 PassRefPtr<ChannelSplitterNode> AudioContext::createChannelSplitter(ExceptionState& exceptionState)
 {
     const unsigned ChannelSplitterDefaultNumberOfOutputs = 6;
     return createChannelSplitter(ChannelSplitterDefaultNumberOfOutputs, exceptionState);
 }
 
 PassRefPtr<ChannelSplitterNode> AudioContext::createChannelSplitter(size_t numberOfOutputs, ExceptionState& exceptionState)
 {
     ASSERT(isMainThread());
-    lazyInitialize();
-
     RefPtr<ChannelSplitterNode> node = ChannelSplitterNode::create(this, m_destinationNode->sampleRate(), numberOfOutputs);
 
     if (!node.get()) {
         exceptionState.throwDOMException(
             IndexSizeError,
             "number of outputs (" + String::number(numberOfOutputs)
             + ") must be between 1 and "
             + String::number(AudioContext::maxNumberOfChannels()) + ".");
         return nullptr;
     }
 
     return node;
 }
 
 PassRefPtr<ChannelMergerNode> AudioContext::createChannelMerger(ExceptionState& exceptionState)
 {
     const unsigned ChannelMergerDefaultNumberOfInputs = 6;
     return createChannelMerger(ChannelMergerDefaultNumberOfInputs, exceptionState);
 }
 
 PassRefPtr<ChannelMergerNode> AudioContext::createChannelMerger(size_t numberOfInputs, ExceptionState& exceptionState)
 {
     ASSERT(isMainThread());
-    lazyInitialize();
-
     RefPtr<ChannelMergerNode> node = ChannelMergerNode::create(this, m_destinationNode->sampleRate(), numberOfInputs);
 
     if (!node.get()) {
         exceptionState.throwDOMException(
             IndexSizeError,
             "number of inputs (" + String::number(numberOfInputs)
             + ") must be between 1 and "
             + String::number(AudioContext::maxNumberOfChannels()) + ".");
         return nullptr;
     }
 
     return node;
 }
 
 PassRefPtr<OscillatorNode> AudioContext::createOscillator()
 {
     ASSERT(isMainThread());
-    lazyInitialize();
-
     RefPtr<OscillatorNode> node = OscillatorNode::create(this, m_destinationNode->sampleRate());
 
     // Because this is an AudioScheduledSourceNode, the context keeps a reference until it has finished playing.
     // When this happens, AudioScheduledSourceNode::finish() calls AudioContext::notifyNodeFinishedProcessing().
     refNode(node.get());
 
     return node;
 }
 
 PassRefPtr<PeriodicWave> AudioContext::createPeriodicWave(Float32Array* real, Float32Array* imag, ExceptionState& exceptionState)
@@ skipping 32 matching lines @@
     }
 
     if (imag->length() > 4096) {
         exceptionState.throwDOMException(
             IndexSizeError,
             "length of imaginary array (" + String::number(imag->length())
             + ") exceeds allowed maximum of 4096");
         return nullptr;
     }
 
-    lazyInitialize();
     return PeriodicWave::create(sampleRate(), real, imag);
 }
 
 void AudioContext::notifyNodeFinishedProcessing(AudioNode* node)
 {
     ASSERT(isAudioThread());
     m_finishedNodes.append(node);
 }
 
 void AudioContext::derefFinishedSourceNodes()
@@ skipping 376 matching lines @@
 }
 
 void AudioContext::decrementActiveSourceCount()
 {
     atomicDecrement(&m_activeSourceCount);
 }
 
 } // namespace WebCore
 
 #endif // ENABLE(WEB_AUDIO)