Implement suspend() and resume() for OfflineAudioContext

third_party/WebKit/Source/modules/webaudio/OfflineAudioContext.cpp

Index: third_party/WebKit/Source/modules/webaudio/OfflineAudioContext.cpp
diff --git a/third_party/WebKit/Source/modules/webaudio/OfflineAudioContext.cpp b/third_party/WebKit/Source/modules/webaudio/OfflineAudioContext.cpp
index b95e4da61988f5074ebc95145d4682c63b41c476..b8050fc54796e24c20a7b7b3d66db62870626bcd 100644
--- a/third_party/WebKit/Source/modules/webaudio/OfflineAudioContext.cpp
+++ b/third_party/WebKit/Source/modules/webaudio/OfflineAudioContext.cpp
@@ -32,6 +32,8 @@
 #include "core/dom/Document.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/ExecutionContext.h"
+#include "modules/webaudio/OfflineAudioCompletionEvent.h"
+#include "modules/webaudio/OfflineAudioDestinationNode.h"
 #include "platform/audio/AudioUtilities.h"
 
 namespace blink {
@@ -93,26 +95,44 @@ OfflineAudioContext* OfflineAudioContext::create(ExecutionContext* context, unsi
 
 OfflineAudioContext::OfflineAudioContext(Document* document, unsigned numberOfChannels, size_t numberOfFrames, float sampleRate)
     : AbstractAudioContext(document, numberOfChannels, numberOfFrames, sampleRate)
+    , m_isRenderingStarted(false)
+    , m_totalRenderFrames(numberOfFrames)
 {
+    // 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();

[Raymond Toy, 2015/10/21 18:22:45]

What happens if m_renderTarget is actually nullptr because the buffer couldn't
be created?

Note that there is a CL in progress that is trying to make DOM arrays throw an
exception if they can't be created. Not sure if we need to do that in this CL.

[hongchan, 2015/10/22 18:23:48]

That means the OAC object cannot be created, we should throw an exception for
that. It was not in the original code, but I agree that we need an check for
that.

 }
 
 OfflineAudioContext::~OfflineAudioContext()
 {
 }
 
+DEFINE_TRACE(OfflineAudioContext)
+{
+    visitor->trace(m_renderTarget);
+    visitor->trace(m_completeResolver);
+    visitor->trace(m_scheduledSuspends);
+    AbstractAudioContext::trace(visitor);
+}
+
 ScriptPromise OfflineAudioContext::startOfflineRendering(ScriptState* scriptState)
 {
+    ASSERT(isMainThread());
+
     // Calling close() on an OfflineAudioContext is not supported/allowed,
-    // but it might well have been stopped by its execution context.
+    // but it might well have been closed by its execution context.
     if (isContextClosed()) {
         return ScriptPromise::rejectWithDOMException(
             scriptState,
             DOMException::create(
                 InvalidStateError,
-                "cannot call startRendering on an OfflineAudioContext in a stopped state."));
+                "cannot call startRendering on an OfflineAudioContext in a closed state."));
     }
 
-    if (m_offlineResolver) {
+    if (m_completeResolver) {
         // Can't call startRendering more than once.  Return a rejected promise now.
         return ScriptPromise::rejectWithDOMException(
             scriptState,
@@ -121,34 +141,240 @@ ScriptPromise OfflineAudioContext::startOfflineRendering(ScriptState* scriptStat
                 "cannot call startRendering more than once"));
     }
 
-    m_offlineResolver = ScriptPromiseResolver::create(scriptState);
-    startRendering();
-    return m_offlineResolver->promise();
+    // If the context is not in the suspended state, reject the promise.
+    if (contextState() != AudioContextState::Suspended) {

[Raymond Toy, 2015/10/21 18:22:45]

Maybe combine this with the case in 127 and use state() to produce the correct
message with the actual state?

[hongchan, 2015/10/22 18:23:49]

Done. Also moved to this check and the ASSERT for m_isRenderingStarted.

PS:

I have tried your suggestion, but I had a crash in
offlineaudiocontext-detached-no-crash.html.

Please see https://code.google.com/p/chromium/issues/detail?id=435867.

isContextClosed() has several meanings and it cannot be replaced with (state()
!= 'closed'). So I will leave this as it is and will tackle this with another
CL.

+        return ScriptPromise::rejectWithDOMException(
+            scriptState,
+            DOMException::create(
+                InvalidStateError,
+                "cannot startRendering when an OfflineAudioContext is not in a suspended state"));
+    }
+
+    m_completeResolver = ScriptPromiseResolver::create(scriptState);
+
+    ASSERT(!m_isRenderingStarted);
+
+    // Start rendering and return the promise.
+    m_isRenderingStarted = true;
+    setContextState(Running);
+    destinationHandler().startRendering();
+
+    return m_completeResolver->promise();
 }
 
 ScriptPromise OfflineAudioContext::closeContext(ScriptState* scriptState)
 {
-    return ScriptPromise::rejectWithDOMException(
-        scriptState,
+    return ScriptPromise::rejectWithDOMException(scriptState,

[Raymond Toy, 2015/10/21 18:22:45]

Does the style checks enforce this?  If not, don't reindent.

[hongchan, 2015/10/22 18:23:48]

Acknowledged. I made it consistent with other parts.

         DOMException::create(InvalidAccessError, "cannot close an OfflineAudioContext."));
 }
 
-ScriptPromise OfflineAudioContext::suspendContext(ScriptState* scriptState)
+ScriptPromise OfflineAudioContext::suspendContext(ScriptState* scriptState, double when)
 {
-    return ScriptPromise::rejectWithDOMException(
-        scriptState,
-        DOMException::create(
-            InvalidAccessError,
-            "cannot suspend an OfflineAudioContext"));
+    ASSERT(isMainThread());
+
+    ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
+    ScriptPromise promise = resolver->promise();
+
+    // The render thread does not exist; reject the promise.
+    if (!destinationHandler().offlineRenderThread()) {
+        resolver->reject(DOMException::create(InvalidStateError,
+            "the rendering is already finished"));
+        return promise;
+    }
+
+    // The specified suspend time is negative; reject the promise.
+    if (when < 0) {
+        resolver->reject(DOMException::create(InvalidStateError,
+            "negative suspend time (" + String::number(when) + ") is not allowed"));
+        return promise;
+    }
+
+    // Quantize (to the lower boundary) the suspend time by the render quantum.
+    size_t frame = when * sampleRate();
+    frame -= frame % destinationHandler().renderQuantumFrames();
+
+    // The suspend time should be earlier than the total render frame. If the
+    // requested suspension time is equal to the total render frame, the promise
+    // will be rejected.
+    if (m_totalRenderFrames <= frame) {
+        resolver->reject(DOMException::create(InvalidStateError,
+            "cannot schedule a suspend at frame " + String::number(frame) +
+            " (" + String::number(when) + " seconds) " +
+            "because it is greater than or equal to the total render duration of " +
+            String::number(m_totalRenderFrames) + " frames"));
+        return promise;
+    }
+
+    // The specified suspend time is in the past; reject the promise.
+    if (frame < currentSampleFrame()) {
+        resolver->reject(DOMException::create(InvalidStateError,
+            "cannot schedule a suspend at frame " +
+            String::number(frame) + " (" + String::number(when) +
+            " seconds) because it is earlier than the current frame of " +
+            String::number(currentSampleFrame()) + " (" +
+            String::number(currentTime()) + " seconds)"));
+        return promise;
+    }
+
+    // If there is a duplicate suspension at the same quantized frame,
+    // reject the promise.
+    if (m_scheduledSuspends.contains(frame)) {
+        resolver->reject(DOMException::create(InvalidStateError,
+            "cannot schedule more than one suspend at frame " +
+            String::number(frame) + " (" +
+            String::number(when) + " seconds)"));
+        return promise;
+    }
+
+    // Wait until the suspend map is available for the insertion.
+    AutoLocker lock(this);
+
+    m_scheduledSuspends.add(frame, resolver);
+
+    return promise;
 }
 
 ScriptPromise OfflineAudioContext::resumeContext(ScriptState* scriptState)
 {
+    ASSERT(isMainThread());
+
+    ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
+    ScriptPromise promise = resolver->promise();
+
+    // If the rendering has not started, reject the promise.
+    if (!m_isRenderingStarted) {
+        resolver->reject(DOMException::create(InvalidStateError,
+            "cannot resume a context that has not started"));

[Raymond Toy, 2015/10/21 18:22:45]

Maybe say "resume an offline context", just to make it more obvious?

[hongchan, 2015/10/22 18:23:48]

Done.

+        return promise;
+    }
+
+    // If the context is not in a suspended or closed state, reject the promise.
+    // TODO(hongchan): there is a conflict in the spec regarding resuming a
+    // running context. Per the current spec, the implementation here rejects
+    // the promise for resuming a running context.
+    if (contextState() != AudioContextState::Suspended) {
+        resolver->reject(DOMException::create(InvalidStateError,
+            "cannot resume a context that is " + state()));
+        return promise;
+    }
+
+    // If the context is suspended, resume rendering by setting the state to
+    // "Running." and calling startRendering(). Note that resuming is possible
+    // only after the rendering started.
+    setContextState(Running);
+    destinationHandler().startRendering();
+
+    // Resolve the promise immediately.
+    resolver->resolve();
+
+    return promise;
+}
+
+ScriptPromise OfflineAudioContext::suspendContext(ScriptState* scriptState)
+{
+    // This CANNOT be called on OfflineAudioContext; this is only to implement
+    // the pure virtual interface from AbstractAudioContext.
+    RELEASE_ASSERT_NOT_REACHED();
+
     return ScriptPromise::rejectWithDOMException(
         scriptState,
         DOMException::create(
-            InvalidAccessError,
-            "cannot resume an OfflineAudioContext"));
+            InvalidStateError,
+            "cannot suspend offline audio context without the specified time."));
+}
+
+void OfflineAudioContext::fireCompletionEvent()
+{
+    ASSERT(isMainThread());
+
+    // We set the state to closed here so that the oncomplete event handler sees
+    // that the context has been closed.
+    setContextState(Closed);
+
+    AudioBuffer* renderedBuffer = renderTarget();
+
+    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 and resolve the
+        // promise too.
+        dispatchEvent(OfflineAudioCompletionEvent::create(renderedBuffer));
+        m_completeResolver->resolve(renderedBuffer);
+    } else {
+        // The resolver should be rejected when the execution context is gone.
+        m_completeResolver->reject(DOMException::create(InvalidStateError,
+            "the execution context does not exist"));
+    }
+}
+
+bool OfflineAudioContext::handlePreOfflineRenderTasks()
+{
+    ASSERT(isAudioThread());
+
+    // This is offline rendering, so it is safe to lock. The offline rendering
+    // is non-realtime process and blocking the non-realtime render is not
+    // problematic. Note that tryLock() cannot be used here because the timing
+    // of suspension should be accurate.
+    deferredTaskHandler().offlineLock();
+
+    deferredTaskHandler().handleDeferredTasks();
+    handleStoppableSourceNodes();
+    deferredTaskHandler().unlock();
+
+    return shouldSuspend();
+}
+
+void OfflineAudioContext::handlePostOfflineRenderTasks()
+{
+    ASSERT(isAudioThread());
+
+    // This is offline rendering, so it is safe to lock with the same reason
+    // described in |handlePreOfflineRenderTasks|.
+    deferredTaskHandler().offlineLock();
+
+    deferredTaskHandler().breakConnections();
+    releaseFinishedSourceNodes();
+    deferredTaskHandler().handleDeferredTasks();
+    deferredTaskHandler().requestToDeleteHandlersOnMainThread();
+
+    deferredTaskHandler().unlock();
+}
+
+
+OfflineAudioDestinationHandler& OfflineAudioContext::destinationHandler()
+{
+    return static_cast<OfflineAudioDestinationHandler&>(destination()->audioDestinationHandler());
+}
+
+void OfflineAudioContext::resolveSuspendOnMainThread(size_t frame)
+{
+    ASSERT(isMainThread());
+
+    // Suspend the context first. This will fire onstatechange event.
+    setContextState(Suspended);
+
+    ASSERT(m_scheduledSuspends.contains(frame));
+
+    // Wait until the suspend map is available for the removal.
+    AutoLocker locker(this);
+
+    SuspendMap::iterator it = m_scheduledSuspends.find(frame);
+    it->value->resolve();
+
+    m_scheduledSuspends.remove(it);
+}
+
+bool OfflineAudioContext::shouldSuspend()
+{
+    ASSERT(isAudioThread());
+
+    if (m_scheduledSuspends.contains(currentSampleFrame()))
+        return true;
+
+    return false;
 }
 
 } // namespace blink