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 94 matching lines @@
     , m_isInitialized(false)
     , m_destinationNode(nullptr)
     , m_isResolvingResumePromises(false)
     , m_automaticPullNodesNeedUpdating(false)
     , m_connectionCount(0)
     , m_didInitializeContextGraphMutex(false)
     , m_audioThread(0)
     , m_isOfflineContext(false)
     , m_contextState(Suspended)
     , m_cachedSampleFrame(0)
+    , m_closedContextSampleRate(-1)

[tkent, 2015/04/07 23:24:47]

This member isn't initialized in another constructor.

 {
     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)
@@ skipping 18 matching lines @@
 
     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.
+
+    // Context is being destroyed.  Reject any decodeAudioData promises that haven't been fulfilled
+    // yet.
+    for (auto& resolver : m_audioDecoderResolvers) {

[haraken, 2015/04/07 23:39:14]

This is unsafe. You're not allowed to touch other on-heap objects in a
destructor. Can we move this reject logic to AudioContext::uninitialize or
something like that?

[yhirano, 2015/04/08 03:19:27]

Rejection is needed when deleting a resolver if 
 - the resolver is not resolved nor rejected, and
 - the execution context is not stopped.

In other words, even when m_audioDecoderResolvers is not empty, you don't have
to reject them if the execution context is already stopped (You need a comment
and / or assertion though).

I'm not sure if the above assumption holds: Just FYI

[Raymond Toy, 2015/04/08 16:47:11]

uninitialize should work.

[Raymond Toy, 2015/04/08 16:47:11]

If this is moved to uninitialize(), then the execution context should still be
around because hasPendingActivity() is true until uninitialize is finished, at
which point hasPendingActivity() returns false.

+        resolver->reject(DOMException::create(InvalidStateError, "Audio context is going away"));
+    }
+    m_audioDecoderResolvers.clear();
+
     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;
+    if (!audioData) {
+        RefPtr<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);

[yhirano, 2015/04/08 03:19:27]

Just to confirm: Is this |resolver.get()| safe in non-oilpan environment? Does
AudioContext live long enough?

[Raymond Toy, 2015/04/08 16:47:11]

I believe so.  As long as uninitialize() has not been called, the AudioContext
should still be alive.

+
+    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();
@@ 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 49 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.keys()) {
         if (node) {
             for (unsigned k = 0; k < node->numberOfOutputs(); ++k)
                 node->disconnectWithoutException(k);
         }
     }
 
     // Stop the audio context. This will stop the destination node from pulling audio anymore. And
     // since we have disconnected the destination from the audio graph, and thus has no references,
     // 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)