AudioContext.decodeAudioData returns a Promise

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 97 matching lines @@
     , m_isCleared(false)
     , m_isInitialized(false)
     , m_destinationNode(nullptr)
     , m_isResolvingResumePromises(false)
     , m_connectionCount(0)
     , m_didInitializeContextGraphMutex(false)
     , m_deferredTaskHandler(DeferredTaskHandler::create())
     , m_isOfflineContext(false)
     , m_contextState(Suspended)
     , m_cachedSampleFrame(0)
+    , m_closedContextSampleRate(-1)
 {
     m_didInitializeContextGraphMutex = true;
     m_destinationNode = DefaultAudioDestinationNode::create(this);
 
     initialize();
 }
 
 // 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_connectionCount(0)
     , m_didInitializeContextGraphMutex(false)
     , m_deferredTaskHandler(DeferredTaskHandler::create())
     , m_isOfflineContext(true)
     , m_contextState(Suspended)
     , m_cachedSampleFrame(0)
+    , m_closedContextSampleRate(-1)
 {
     m_didInitializeContextGraphMutex = true;
     // 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()
 {
 #if DEBUG_AUDIONODE_REFERENCES
     fprintf(stderr, "%p: AudioContext::~AudioContext(): %u\n", this, m_contextId);
 #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_suspendResolvers.size());
     ASSERT(!m_isResolvingResumePromises);
     ASSERT(!m_resumeResolvers.size());
+    ASSERT(!m_audioDecoderResolvers.size());
 }
 
 void AudioContext::initialize()
 {
     if (isInitialized())
         return;
 
     FFTFrame::initialize();
     m_listener = AudioListener::create();
 
@@ skipping 55 matching lines @@
     if (!isOfflineContext())
         setContextState(Closed);
 
     // Resolve the promise now, if any
     if (m_closeResolver)
         m_closeResolver->resolve();
 
     ASSERT(m_listener);
     m_listener->waitForHRTFDatabaseLoaderThreadCompletion();
 
+    // Reject any decodeAudioData promises that haven't been fulfilled yet.
+    for (auto& resolver : m_audioDecoderResolvers) {
+        resolver->reject(DOMException::create(InvalidStateError, "Audio context is going away"));
+    }
+    m_audioDecoderResolvers.clear();
+
+    // Uninitialization done, so clear flags to indicate that the AudioContext has no pending
+    // activity anymore.
     clear();
 }
 
 void AudioContext::stop()
 {
     // Usually ExecutionContext calls stop twice.
     if (m_isStopScheduled)
         return;
     m_isStopScheduled = true;
 
@@ skipping 16 matching lines @@
 }
 
 AudioBuffer* AudioContext::createBuffer(unsigned numberOfChannels, size_t numberOfFrames, float sampleRate, ExceptionState& exceptionState)
 {
     // It's ok to call createBuffer, even if the context is closed because the AudioBuffer doesn't
     // really "belong" to any particular context.
 
     return AudioBuffer::create(numberOfChannels, numberOfFrames, sampleRate, exceptionState);
 }
 
-void AudioContext::decodeAudioData(DOMArrayBuffer* audioData, AudioBufferCallback* successCallback, AudioBufferCallback* errorCallback, ExceptionState& exceptionState)
+ScriptPromise AudioContext::decodeAudioData(ScriptState* scriptState, DOMArrayBuffer* audioData, AudioBufferCallback* successCallback, AudioBufferCallback* errorCallback, ExceptionState& exceptionState)
 {
-    if (isContextClosed()) {
-        throwExceptionForClosedState(exceptionState);
-        return;
+    if (!audioData) {
+        RefPtrWillBeRawPtr<DOMException> error = DOMException::create(
+            NotSupportedError,
+            "invalid ArrayBuffer for audioData.");
+        if (errorCallback) {
+            errorCallback->handleEvent(error.get());
+        }
+        return ScriptPromise::rejectWithDOMException(scriptState, error);
     }
 
-    if (!audioData) {
-        exceptionState.throwDOMException(
-            SyntaxError,
-            "invalid ArrayBuffer for audioData.");
-        return;
-    }
-    m_audioDecoder.decodeAsync(audioData, sampleRate(), successCallback, errorCallback);
+    RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
+    ScriptPromise promise = resolver->promise();
+
+    m_audioDecoderResolvers.append(resolver);
+
+    float rate = isContextClosed() ? m_closedContextSampleRate : sampleRate();
+
+    ASSERT(rate > 0);
+
+    m_audioDecoder.decodeAsync(audioData, rate, successCallback, errorCallback, resolver.get(), this);
+
+    return promise;
 }
 
 AudioBufferSourceNode* AudioContext::createBufferSource(ExceptionState& exceptionState)
 {
     ASSERT(isMainThread());
 
     if (isContextClosed()) {
         throwExceptionForClosedState(exceptionState);
         return nullptr;
     }
@@ skipping 609 matching lines @@
     // Find AudioBufferSourceNodes to see if we can stop playing them.
     for (unsigned i = 0; i < m_referencedNodes.size(); ++i) {
         AudioNode* node = m_referencedNodes.at(i).get();
 
         if (node->handler().nodeType() == AudioHandler::NodeTypeAudioBufferSource) {
             AudioBufferSourceNode* sourceNode = static_cast<AudioBufferSourceNode*>(node);
             sourceNode->audioBufferSourceHandler().handleStoppableSourceNode();
         }
     }
 }
+
+void AudioContext::removeAudioDecoderResolver(ScriptPromiseResolver* resolver)
+{
+    ASSERT(isMainThread());
+
+    for (size_t k = 0; k < m_audioDecoderResolvers.size(); ++k) {
+        if (resolver == m_audioDecoderResolvers.at(k)) {
+            m_audioDecoderResolvers.remove(k);
+            break;
+        }
+    }
+}
+
 void AudioContext::handlePreRenderTasks()
 {
     ASSERT(isAudioThread());
 
     // At the beginning of every render quantum, try to update the internal rendering graph state (from main thread changes).
     // It's OK if the tryLock() fails, we'll just take slightly longer to pick up the changes.
     if (tryLock()) {
         handler().handleDeferredTasks();
 
         resolvePromisesForResume();
@@ skipping 197 matching lines @@
 
     // Resolve any pending promises created by suspend()
     if (m_suspendResolvers.size() > 0)
         Platform::current()->mainThread()->postTask(FROM_HERE, bind(&AudioContext::resolvePromisesForSuspendOnMainThread, this));
 }
 
 void AudioContext::rejectPendingResolvers()
 {
     ASSERT(isMainThread());
 
-    // Audio context is closing down so reject any suspend or resume promises that are still
-    // pending.
+    // Audio context is closing down so reject any promises that are still pending.
 
     for (auto& resolver : m_suspendResolvers) {
         resolver->reject(DOMException::create(InvalidStateError, "Audio context is going away"));
     }
     m_suspendResolvers.clear();
 
     for (auto& resolver : m_resumeResolvers) {
         resolver->reject(DOMException::create(InvalidStateError, "Audio context is going away"));
     }
     m_resumeResolvers.clear();
@@ skipping 53 matching lines @@
     // Avoid firing the event if the document has already gone away.
     if (executionContext()) {
         // Call the offline rendering completion event listener and resolve the promise too.
         dispatchEvent(OfflineAudioCompletionEvent::create(renderedBuffer));
         m_offlineResolver->resolve(renderedBuffer);
     }
 }
 
 DEFINE_TRACE(AudioContext)
 {
+    visitor->trace(m_audioDecoderResolvers);
     visitor->trace(m_closeResolver);
     visitor->trace(m_offlineResolver);
     visitor->trace(m_renderTarget);
     visitor->trace(m_destinationNode);
     visitor->trace(m_listener);
     // trace() can be called in AudioContext constructor, and
     // m_contextGraphMutex might be unavailable.
     if (m_didInitializeContextGraphMutex) {
         AutoLocker lock(this);
         visitor->trace(m_referencedNodes);
@@ skipping 47 matching lines @@
 
     if (isContextClosed()) {
         // We've already closed the context previously, but it hasn't yet been resolved, so just
         // create a new promise and reject it.
         return ScriptPromise::rejectWithDOMException(
             scriptState,
             DOMException::create(InvalidStateError,
                 "Cannot close a context that is being closed or has already been closed."));
     }
 
+    // Save the current sample rate for any subsequent decodeAudioData calls.
+    m_closedContextSampleRate = sampleRate();
+
     m_closeResolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = m_closeResolver->promise();
 
     // Before closing the context go and disconnect all nodes, allowing them to be collected. This
     // will also break any connections to the destination node. Any unfinished sourced nodes will
     // get stopped when the context is unitialized.
     for (auto& node : m_liveNodes) {
         if (node) {
             for (unsigned k = 0; k < node->numberOfOutputs(); ++k)
                 node->disconnectWithoutException(k);
@@ skipping 39 matching lines @@
 DeferredTaskHandler::AutoLocker::AutoLocker(AudioContext* context)
     : m_handler(context->handler())
 {
     m_handler.lock();
 }
 
 
 } // namespace blink
 
 #endif // ENABLE(WEB_AUDIO)