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 142 matching lines @@
     ASSERT(!m_isInitialized);
     ASSERT(!m_referencedNodes.size());
     ASSERT(!m_finishedNodes.size());
     ASSERT(!m_automaticPullNodes.size());
     if (m_automaticPullNodesNeedUpdating)
         m_renderingAutomaticPullNodes.resize(m_automaticPullNodes.size());
     ASSERT(!m_renderingAutomaticPullNodes.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 92 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;
+        return ScriptPromise::rejectWithDOMException(
+            scriptState,
+            DOMException::create(
+                InvalidStateError,
+                "AudioContext has been closed."));
     }
 
     if (!audioData) {
-        exceptionState.throwDOMException(
-            SyntaxError,
-            "invalid ArrayBuffer for audioData.");
-        return;
+        if (errorCallback)
+            errorCallback->handleEvent(nullptr);
+        return ScriptPromise::rejectWithDOMException(
+            scriptState,
+            DOMException::create(
+                NotSupportedError,
+                "invalid ArrayBuffer for audioData."));
     }
-    m_audioDecoder.decodeAsync(audioData, sampleRate(), successCallback, errorCallback);
+
+    RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
+    ScriptPromise promise = resolver->promise();
+
+    m_audioDecoderResolvers.append(resolver);
+
+    m_audioDecoder.decodeAsync(audioData, sampleRate(), successCallback, errorCallback, resolver.get(), this);
+
+    return promise;
 }
 
 AudioBufferSourceNode* AudioContext::createBufferSource(ExceptionState& exceptionState)
 {
     ASSERT(isMainThread());
 
     if (isContextClosed()) {
         throwExceptionForClosedState(exceptionState);
         return nullptr;
     }
@@ skipping 642 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->nodeType() == AudioNode::NodeTypeAudioBufferSource) {
             AudioBufferSourceNode* sourceNode = static_cast<AudioBufferSourceNode*>(node);
             sourceNode->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()) {
         // Update the channel count mode.
         updateChangedChannelCountMode();
 
@@ skipping 230 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();
     m_isResolvingResumePromises = false;
+
+    for (auto& resolver : m_audioDecoderResolvers) {
+        resolver->reject(DOMException::create(InvalidStateError, "Audio context is going away"));
+    }
+    m_audioDecoderResolvers.clear();
 }
 
 const AtomicString& AudioContext::interfaceName() const
 {
     return EventTargetNames::AudioContext;
 }
 
 ExecutionContext* AudioContext::executionContext() const
 {
     return m_isStopScheduled ? 0 : ActiveDOMObject::executionContext();
@@ skipping 42 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 74 matching lines @@
     // the destination node can GCed if JS has no references. stop() will also resolve the Promise
     // created here.
     stop();
 
     return promise;
 }
 
 } // namespace blink
 
 #endif // ENABLE(WEB_AUDIO)