Implement suspend/resume for AudioContext

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 12 matching lines @@
  */
 
 #include "config.h"
 
 #if ENABLE(WEB_AUDIO)
 
 #include "modules/webaudio/AudioContext.h"
 
 #include "bindings/core/v8/ExceptionMessages.h"
 #include "bindings/core/v8/ExceptionState.h"
+#include "bindings/core/v8/ScriptState.h"
+#include "core/dom/DOMException.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/html/HTMLMediaElement.h"
 #include "core/inspector/ScriptCallStack.h"
 #include "platform/audio/FFTFrame.h"
 #include "platform/audio/HRTFPanner.h"
 #include "modules/mediastream/MediaStream.h"
 #include "modules/webaudio/AnalyserNode.h"
 #include "modules/webaudio/AudioBuffer.h"
 #include "modules/webaudio/AudioBufferCallback.h"
@@ skipping 51 matching lines @@
     return audioContext;
 }
 
 // Constructor for rendering to the audio hardware.
 AudioContext::AudioContext(Document* document)
     : ActiveDOMObject(document)
     , m_isStopScheduled(false)
     , m_isCleared(false)
     , m_isInitialized(false)
     , m_destinationNode(nullptr)
+    , m_isResolvingResumePromises(false)
     , m_automaticPullNodesNeedUpdating(false)
     , m_connectionCount(0)
     , m_audioThread(0)
     , m_isOfflineContext(false)
+    , m_contextState(Paused)
 {
     m_destinationNode = DefaultAudioDestinationNode::create(this);
 
     initialize();
 #if DEBUG_AUDIONODE_REFERENCES
     fprintf(stderr, "%p: AudioContext::AudioContext() #%u\n", this, AudioContext::s_hardwareContextCount);
 #endif
 }
 
 // Constructor for offline (non-realtime) rendering.
 AudioContext::AudioContext(Document* document, unsigned numberOfChannels, size_t numberOfFrames, float sampleRate)
     : ActiveDOMObject(document)
     , m_isStopScheduled(false)
     , m_isCleared(false)
     , m_isInitialized(false)
     , m_destinationNode(nullptr)
+    , m_isResolvingResumePromises(false)
     , m_automaticPullNodesNeedUpdating(false)
     , m_connectionCount(0)
     , m_audioThread(0)
     , m_isOfflineContext(true)
+    , m_contextState(Paused)
 {
     // Create a new destination for offline rendering.
     m_renderTarget = AudioBuffer::create(numberOfChannels, numberOfFrames, sampleRate);
     if (m_renderTarget.get())
         m_destinationNode = OfflineAudioDestinationNode::create(this, m_renderTarget.get());
 
     initialize();
 }
 
 AudioContext::~AudioContext()

[haraken, 2014/10/16 01:13:43]

Can we add ASSERT(!m_resumePromises.size())?

[Raymond Toy, 2014/10/16 17:56:31]

Done.

 {
 #if DEBUG_AUDIONODE_REFERENCES
     fprintf(stderr, "%p: AudioContext::~AudioContext()\n", this);
 #endif
     // AudioNodes keep a reference to their context, so there should be no way to be in the destructor if there are still AudioNodes around.
     ASSERT(!m_isInitialized);
     ASSERT(!m_referencedNodes.size());
     ASSERT(!m_finishedNodes.size());
     ASSERT(!m_automaticPullNodes.size());
     if (m_automaticPullNodesNeedUpdating)
@@ skipping 10 matching lines @@
     m_listener = AudioListener::create();
 
     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();
+            startRendering();
             ++s_hardwareContextCount;
         }
 
         m_isInitialized = true;
     }
 }
 
 void AudioContext::clear()
 {
     // We need to run disposers before destructing m_contextGraphMutex.
@@ skipping 345 matching lines @@
         exceptionState.throwDOMException(
             IndexSizeError,
             "length of imaginary array (" + String::number(imag->length())
             + ") exceeds allowed maximum of 4096");
         return 0;
     }
 
     return PeriodicWave::create(sampleRate(), real, imag);
 }
 
+String AudioContext::state() const
+{
+    switch (m_contextState) {
+    case Paused:
+        return "paused";
+    case Running:
+        return "running";
+    case Released:
+        return "released";
+    }
+    ASSERT_NOT_REACHED();
+    return "";
+}
+
+void AudioContext::setContextState(AudioContextState newState)
+{
+    // Validate the transitions
+    switch (newState) {
+    case Paused:
+        ASSERT(m_contextState == Running);
+        break;
+    case Running:
+        ASSERT(m_contextState == Paused);
+        break;
+    case Released:
+        ASSERT(m_contextState != Released);
+        break;
+    }
+
+    m_contextState = newState;
+}
+
+void AudioContext::suspendContext(ExceptionState& exceptionState)
+{
+    ASSERT(isMainThread());
+    AutoLocker locker(this);
+
+    if (m_contextState == Released) {
+        exceptionState.throwDOMException(
+            InvalidStateError,
+            "cannot suspend an AudioContext that has been released");
+        return;
+    }
+
+    if (m_destinationNode && !isOfflineContext()) {
+        stopRendering();
+    }
+}
+
+ScriptPromise AudioContext::resumeContext(ScriptState* scriptState)
+{
+    ASSERT(isMainThread());
+    AutoLocker locker(this);
+
+    RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
+
+    ScriptPromise promise = resolver->promise();
+
+    if (isOfflineContext()) {
+        // For offline context, resolve now, but reject if the context has been released.
+        if (m_contextState == Released) {
+            resolver->reject(
+                DOMException::create(InvalidStateError, "Cannot resume a context that has been released"));
+        } else {
+            resolver->resolve();
+        }
+    } else {
+        // Restart the destination node to pull on the audio graph.
+        if (m_destinationNode) {
+            startRendering();
+        }
+
+        // Save the promise which will get resolved when the destination node starts pulling on the
+        // graph again.
+        m_resumePromises.append(resolver);
+    }
+
+    return promise;
+}
+
 void AudioContext::notifyNodeFinishedProcessing(AudioNode* node)
 {
     ASSERT(isAudioThread());
     m_finishedNodes.append(node);
 }
 
 void AudioContext::derefFinishedSourceNodes()
 {
     ASSERT(isGraphOwner());
     ASSERT(isAudioThread());
@@ skipping 86 matching lines @@
     // It's OK if the tryLock() fails, we'll just take slightly longer to pick up the changes.
     if (tryLock()) {
         // Update the channel count mode.
         updateChangedChannelCountMode();
 
         // Fixup the state of any dirty AudioSummingJunctions and AudioNodeOutputs.
         handleDirtyAudioSummingJunctions();
         handleDirtyAudioNodeOutputs();
 
         updateAutomaticPullNodes();
+        resolvePromisesForResume();
+
         unlock();
     }
 }
 
 void AudioContext::handlePostRenderTasks()
 {
     ASSERT(isAudioThread());
 
     // Must use a tryLock() here too.  Don't worry, the lock will very rarely be contended and this method is called frequently.
     // The worst that can happen is that there will be some nodes which will take slightly longer than usual to be deleted or removed
@@ skipping 145 matching lines @@
 }
 
 void AudioContext::processAutomaticPullNodes(size_t framesToProcess)
 {
     ASSERT(isAudioThread());
 
     for (unsigned i = 0; i < m_renderingAutomaticPullNodes.size(); ++i)
         m_renderingAutomaticPullNodes[i]->processIfNecessary(framesToProcess);
 }
 
+void AudioContext::resolvePromisesForResumeOnMainThread()
+{
+    ASSERT(isMainThread());
+    AutoLocker locker(this);
+
+    for (unsigned k = 0; k < m_resumePromises.size(); ++k) {
+        if (m_contextState == Released) {
+            m_resumePromises[k]->reject(
+                DOMException::create(InvalidStateError, "Cannot resume a context that has been released"));
+        } else {
+            m_resumePromises[k]->resolve();
+        }
+    }
+
+    m_resumePromises.clear();
+    m_isResolvingResumePromises = false;
+}
+
+void AudioContext::resolvePromisesForResume()
+{
+    // This runs inside the AudioContext's lock when handling pre-render tasks.
+    ASSERT(isAudioThread());
+    ASSERT(isGraphOwner());
+
+    // Resolve any pending promises created by resume(). Only do this we if haven't already started
+    // resolving these promises. This gets called very often and it takes some time to resolve the
+    // promises in the main thread.
+    if (!m_isResolvingResumePromises && m_resumePromises.size() > 0) {
+        m_isResolvingResumePromises = true;
+        callOnMainThread(bind(&AudioContext::resolvePromisesForResumeOnMainThread, this));
+    }
+}
+
 const AtomicString& AudioContext::interfaceName() const
 {
     return EventTargetNames::AudioContext;
 }
 
 ExecutionContext* AudioContext::executionContext() const
 {
     return m_isStopScheduled ? 0 : ActiveDOMObject::executionContext();
 }
 
 void AudioContext::startRendering()
 {
-    destination()->startRendering();
+    ASSERT(isMainThread());

[haraken, 2014/10/16 01:13:43]

Shall we add ASSERT(!isOfflineContext())?

[haraken, 2014/10/16 01:13:43]

Shall we add ASSERT(m_destinationNode)?

[Raymond Toy, 2014/10/16 17:56:31]

Done.

[Raymond Toy, 2014/10/16 17:56:31]

Actually no.  startRendering is called for both online and offline contexts from
V8.

+
+    if (m_contextState == Paused) {
+        destination()->startRendering();
+        setContextState(Running);
+    }
+}
+
+void AudioContext::stopRendering()
+{
+    ASSERT(isMainThread());
+    ASSERT(m_destinationNode);
+    ASSERT(!isOfflineContext());
+
+    if (m_contextState == Running) {
+        destination()->stopRendering();
+        setContextState(Paused);
+    }
 }
 
 void AudioContext::fireCompletionEvent()
 {
     ASSERT(isMainThread());
     if (!isMainThread())
         return;
 
     AudioBuffer* renderedBuffer = m_renderTarget.get();
 
+    setContextState(Released);
+
     ASSERT(renderedBuffer);
     if (!renderedBuffer)
         return;
 
     // Avoid firing the event if the document has already gone away.
     if (executionContext()) {
         // Call the offline rendering completion event listener.
         dispatchEvent(OfflineAudioCompletionEvent::create(renderedBuffer));
     }
 }
@@ skipping 29 matching lines @@
 
     for (HashSet<AudioNode*>::iterator k = m_deferredCountModeChange.begin(); k != m_deferredCountModeChange.end(); ++k)
         (*k)->updateChannelCountMode();
 
     m_deferredCountModeChange.clear();
 }
 
 } // namespace blink
 
 #endif // ENABLE(WEB_AUDIO)