Implement suspend/resume for AudioContext

Source/modules/webaudio/AudioContext.h

 /*
  * 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
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef AudioContext_h
 #define AudioContext_h
 
+#include "bindings/core/v8/ScriptPromise.h"
+#include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "core/dom/ActiveDOMObject.h"
 #include "core/events/EventListener.h"
 #include "modules/EventTargetModules.h"
 #include "modules/webaudio/AsyncAudioDecoder.h"
 #include "modules/webaudio/AudioDestinationNode.h"
 #include "platform/audio/AudioBus.h"
 #include "platform/heap/Handle.h"
 #include "wtf/HashSet.h"
 #include "wtf/MainThread.h"
 #include "wtf/OwnPtr.h"
@@ skipping 32 matching lines @@
 class WaveShaperNode;
 
 // AudioContext is the cornerstone of the web audio API and all AudioNodes are created from it.
 // For thread safety between the audio thread and the main thread, it has a rendering graph locking mechanism.
 
 class AudioContext : public RefCountedGarbageCollectedWillBeGarbageCollectedFinalized<AudioContext>, public ActiveDOMObject, public EventTargetWithInlineData {
     DEFINE_EVENT_TARGET_REFCOUNTING_WILL_BE_REMOVED(RefCountedGarbageCollected<AudioContext>);
     DEFINE_WRAPPERTYPEINFO();
     WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(AudioContext);
 public:
+    // The state of an audio context.  On creation, the state is Paused. The state is Running if
+    // audio is being processed (audio graph is being pulled for data). The state is Released if the
+    // audio context has been released.  The valid transitions are from Paused to either Running or
+    // Released; Running to Paused or Released. Once Released, there are no valid transitions.
+    enum AudioContextState {
+        Paused,
+        Running,
+        Released
+    };
+
     // Create an AudioContext for rendering to the audio hardware.
     static AudioContext* create(Document&, ExceptionState&);
 
     virtual ~AudioContext();
 
     virtual void trace(Visitor*) override;
 
     bool isInitialized() const { return m_isInitialized; }
     bool isOfflineContext() { return m_isOfflineContext; }
 
     // Document notification
     virtual void stop() override final;
     virtual bool hasPendingActivity() const override;
 
     AudioDestinationNode* destination() { return m_destinationNode.get(); }
     size_t currentSampleFrame() const { return m_destinationNode->currentSampleFrame(); }
     double currentTime() const { return m_destinationNode->currentTime(); }
     float sampleRate() const { return m_destinationNode->sampleRate(); }
+    String state() const;
 
     AudioBuffer* createBuffer(unsigned numberOfChannels, size_t numberOfFrames, float sampleRate, ExceptionState&);
 
     // Asynchronous audio file data decoding.
     void decodeAudioData(ArrayBuffer*, AudioBufferCallback*, AudioBufferCallback*, ExceptionState&);
 
     AudioListener* listener() { return m_listener.get(); }
 
     // The AudioNode create methods are called on the main thread (from JavaScript).
     AudioBufferSourceNode* createBufferSource();
@@ skipping 13 matching lines @@
     ScriptProcessorNode* createScriptProcessor(size_t bufferSize, ExceptionState&);
     ScriptProcessorNode* createScriptProcessor(size_t bufferSize, size_t numberOfInputChannels, ExceptionState&);
     ScriptProcessorNode* createScriptProcessor(size_t bufferSize, size_t numberOfInputChannels, size_t numberOfOutputChannels, ExceptionState&);
     ChannelSplitterNode* createChannelSplitter(ExceptionState&);
     ChannelSplitterNode* createChannelSplitter(size_t numberOfOutputs, ExceptionState&);
     ChannelMergerNode* createChannelMerger(ExceptionState&);
     ChannelMergerNode* createChannelMerger(size_t numberOfInputs, ExceptionState&);
     OscillatorNode* createOscillator();
     PeriodicWave* createPeriodicWave(Float32Array* real, Float32Array* imag, ExceptionState&);
 
+    // Pause/Resume
+    void suspendContext(ExceptionState&);
+    ScriptPromise resumeContext(ScriptState*);
+
     // When a source node has no more processing to do (has finished playing), then it tells the context to dereference it.
     void notifyNodeFinishedProcessing(AudioNode*);
 
     // Called at the start of each render quantum.
     void handlePreRenderTasks();
 
     // Called at the end of each render quantum.
     void handlePostRenderTasks();
 
     // Called periodically at the end of each render quantum to dereference finished source nodes.
@@ skipping 126 matching lines @@
     GC_PLUGIN_IGNORE("http://crbug.com/404527")
     Vector<AudioNode*> m_finishedNodes;
 
     // List of source nodes. This is either accessed when the graph lock is
     // held, or on the main thread when the audio thread has finished.
     // Oilpan: This Vector holds connection references. We must call
     // AudioNode::makeConnection when we add an AudioNode to this, and must call
     // AudioNode::breakConnection() when we remove an AudioNode from this.
     HeapVector<Member<AudioNode> > m_referencedNodes;
 
+    // Stop rendering the audio graph.
+    void stopRendering();
+
+    // Handle Promises for resume().
+    void resolvePromisesForResume();
+    void resolvePromisesForResumeOnMainThread();
+
+    // Vector of promises created by resume(). It takes time to handle them, so we collect all of
+    // the promises here until they can be resolved or rejected.
+    Vector<RefPtr<ScriptPromiseResolver> > m_resumePromises;
+
+    // True if we're in the process of resolving promises for resume().  Resolving can take some
+    // time and the audio context process loop is very fast, so we don't want to call resolve an
+    // excessive number of times.
+    bool m_isResolvingResumePromises;
+
     class AudioNodeDisposer {
     public:
         explicit AudioNodeDisposer(AudioNode& node) : m_node(node) { }
         ~AudioNodeDisposer();
 
     private:
         AudioNode& m_node;
     };
     HeapHashMap<WeakMember<AudioNode>, OwnPtr<AudioNodeDisposer> > m_liveNodes;
 
@@ skipping 44 matching lines @@
     // Only accessed in the audio thread.
     // Oilpan: Since items are added to these vectors by the audio thread (not registered to Oilpan),
     // we cannot use HeapVectors.
     GC_PLUGIN_IGNORE("http://crbug.com/404527")
     Vector<AudioNode*> m_deferredBreakConnectionList;
 
     Member<AudioBuffer> m_renderTarget;
 
     bool m_isOfflineContext;
 
+    AudioContextState m_contextState;
+    void setContextState(AudioContextState);
+
     AsyncAudioDecoder m_audioDecoder;
 
     // Collection of nodes where the channel count mode has changed. We want the channel count mode
     // to change in the pre- or post-rendering phase so as not to disturb the running audio thread.
     GC_PLUGIN_IGNORE("http://crbug.com/404527")
     HashSet<AudioNode*> m_deferredCountModeChange;
 
     // This is considering 32 is large enough for multiple channels audio.
     // It is somewhat arbitrary and could be increased if necessary.
     enum { MaxNumberOfChannels = 32 };
 };
 
 } // namespace blink
 
 #endif // AudioContext_h